projectmoon
/
ai-game
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
ai-game/Cargo.lock

2990 lines
72 KiB
Plaintext
Raw Normal View History

Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
# This file is automatically @generated by Cargo.
# It is not intended for manual editing.
version = 3
[[package]]
name = "addr2line"
version = "0.21.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb"
dependencies = [
"gimli",
]
[[package]]
name = "adler"
version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
[[package]]
name = "ahash"
version = "0.7.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a824f2aa7e75a0c98c5a504fceb80649e9c35265d44525b5f94de4771a395cd"
dependencies = [
"getrandom",
"once_cell",
"version_check",
]
[[package]]
name = "ahash"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.8.7"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"cfg-if",
"getrandom",
"once_cell",
"version_check",
"zerocopy",
]
[[package]]
name = "aho-corasick"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0"
dependencies = [
"memchr",
]
[[package]]
name = "ai-game"
version = "0.1.0"
dependencies = [
"anyhow",
"arangors",
"async-recursion",
"async-trait",
"config",
"crossterm",
"eventsource-client",
"futures",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"gbnf",
"gbnf_derive",
"itertools 0.12.1",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"polodb_core",
"prettyplease",
"progenitor",
"progenitor-client",
"reedline",
"reqwest",
"serde",
"serde_json",
"strum",
"syn 1.0.109",
Look at people and items in a scene. Non-LLM coherence. Adds the ability to inspect people or items in a scene. Also technically props, but they are not first class entities (i.e. stored in DB with an ID), so the LLM will behave oddly if you attempt to look at a prop. Also adds the foundation of non-LLM + LLM command coherence to fix up LLM responses from LLM command execution. CommandEvents that are recognized as incoherent will attempt to be fixed by the command coherence layer. Currently only non-LLM coherence checks are done (normalizing IDs, making sure they are right, etc). Also many changes to command execution prompt to make it more intelligent and correct. Many foundational pieces for building actual game mechanics and in-depth coherence are also added.
2024-01-30 11:03:32 +00:00
"tabled",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"textwrap",
"thiserror",
"tokio",
"uuid",
]
[[package]]
name = "android-tzdata"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e999941b234f3131b00bc13c22d06e8c5ff726d1b6318ac7eb276997bbb4fef0"
[[package]]
name = "android_system_properties"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
dependencies = [
"libc",
]
[[package]]
name = "anyhow"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.79"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "080e9890a082662b09c1ad45f567faeeb47f22b5fb23895fbe1e651e718e25ca"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "arangors"
version = "0.5.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e16853bc26550fe3c09e3c6c77e595108c3634fc6d1161e52408ca786095903"
dependencies = [
"async-trait",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"base64 0.21.7",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"http",
"log",
"maybe-async",
"serde",
"serde_json",
"serde_qs",
"thiserror",
"typed-builder",
"uclient",
"url",
]
[[package]]
name = "async-compression"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.6"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "a116f46a969224200a0a97f29cfd4c50e7534e4b4826bd23ea2c3c533039c82c"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"flate2",
"futures-core",
"memchr",
"pin-project-lite",
"tokio",
]
[[package]]
name = "async-recursion"
version = "1.0.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5fd55a5ba1179988837d24ab4c7cc8ed6efdeff578ede0416b4225a5fca35bd0"
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "async-trait"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.1.77"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "c980ee35e870bd1a4d2c8294d4c04d0499e67bca1e4b5cefcc693c2fa00caea9"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "atomic"
version = "0.5.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c59bdb34bc650a32731b31bd8f0829cc15d24a708ee31559e0bb34f2bc320cba"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "auto_impl"
version = "1.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "823b8bb275161044e2ac7a25879cb3e2480cb403e3943022c7c769c599b756aa"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.48",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "autocfg"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
[[package]]
name = "backtrace"
version = "0.3.69"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837"
dependencies = [
"addr2line",
"cc",
"cfg-if",
"libc",
"miniz_oxide",
"object",
"rustc-demangle",
]
[[package]]
name = "base64"
version = "0.13.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8"
[[package]]
name = "base64"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.21.7"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "bitflags"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "bitflags"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.4.2"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "ed570934406eb16438a4e976b1b4500774099c13b8cb96eec99f620f05090ddf"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"serde",
]
[[package]]
name = "bitvec"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
dependencies = [
"funty",
"radium",
"tap",
"wyz",
]
[[package]]
name = "block-buffer"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
dependencies = [
"generic-array",
]
[[package]]
name = "bson"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.9.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "ce21468c1c9c154a85696bb25c20582511438edb6ad67f846ba1378ffdd80222"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"ahash 0.8.7",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"base64 0.13.1",
"bitvec",
"hex",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"indexmap 2.2.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"js-sys",
"once_cell",
"rand",
"serde",
"serde_bytes",
"serde_json",
"time",
"uuid",
]
[[package]]
name = "bumpalo"
version = "3.14.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec"
Look at people and items in a scene. Non-LLM coherence. Adds the ability to inspect people or items in a scene. Also technically props, but they are not first class entities (i.e. stored in DB with an ID), so the LLM will behave oddly if you attempt to look at a prop. Also adds the foundation of non-LLM + LLM command coherence to fix up LLM responses from LLM command execution. CommandEvents that are recognized as incoherent will attempt to be fixed by the command coherence layer. Currently only non-LLM coherence checks are done (normalizing IDs, making sure they are right, etc). Also many changes to command execution prompt to make it more intelligent and correct. Many foundational pieces for building actual game mechanics and in-depth coherence are also added.
2024-01-30 11:03:32 +00:00
[[package]]
name = "bytecount"
version = "0.6.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e1e5f035d16fc623ae5f74981db80a439803888314e3a555fd6f04acd51a3205"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "byteorder"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1fd0f2584146f6f2ef48085050886acf353beff7305ebd1ae69500e27c67f64b"
[[package]]
name = "bytes"
version = "1.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223"
[[package]]
name = "cc"
version = "1.0.83"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
dependencies = [
"libc",
]
[[package]]
name = "cfg-if"
version = "1.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]]
name = "chrono"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.33"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "9f13690e35a5e4ace198e7beea2895d29f3a9cc55015fcebe6336bd2010af9eb"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"android-tzdata",
"iana-time-zone",
"num-traits",
"serde",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-targets 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "config"
version = "0.13.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23738e11972c7643e4ec947840fc463b6a571afcd3e735bdfce7d03c7a784aca"
dependencies = [
"async-trait",
"json5",
"lazy_static",
"nom",
"pathdiff",
"ron",
"rust-ini",
"serde",
"serde_json",
"toml",
"yaml-rust",
]
Allow limiting of values on derive(Gbnf) structs. With the new helper attribute #[gbnf_limit] on a field of a struct that has #[derive(Gbnf)], it is now possible to constrain the output of the LLM to a specific set of values for that field. This is extremely useful, for example, when asking the LLM to put a specific ID in a field. This commit also addresses numerous shortcomings of the original implementation of the derive macro. Deserialization of certain LLM responses currently broken as of this commit, due to different field names in the LLM output vs what serde expects (camelCase vs snake_case issues).
2024-02-07 11:01:47 +00:00
[[package]]
name = "convert_case"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec182b0ca2f35d8fc196cf3404988fd8b8c739a4d270ff118a398feb0cbec1ca"
dependencies = [
"unicode-segmentation",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "core-foundation"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.9.4"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "core-foundation-sys"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.8.6"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "cpufeatures"
version = "0.2.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53fe5e26ff1b7aef8bca9c6080520cfb8d9333c7568e1829cef191a9723e5504"
dependencies = [
"libc",
]
[[package]]
name = "crc32fast"
version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d"
dependencies = [
"cfg-if",
]
[[package]]
name = "crc64fast"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.1.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "26bb92ecea20291efcf0009e2713d64b7e327dedb8ce780545250f24075429e2"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "crossterm"
version = "0.27.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f476fe445d41c9e991fd07515a6f463074b782242ccf4a5b7b1d1012e70824df"
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"bitflags 2.4.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"crossterm_winapi",
"libc",
"mio",
"parking_lot",
"serde",
"signal-hook",
"signal-hook-mio",
"winapi",
]
[[package]]
name = "crossterm_winapi"
version = "0.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "acdd7c62a3665c7f6830a51635d9ac9b23ed385797f70a83bb8bafe9c572ab2b"
dependencies = [
"winapi",
]
[[package]]
name = "crypto-common"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3"
dependencies = [
"generic-array",
"typenum",
]
[[package]]
name = "ct-logs"
version = "0.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c1a816186fa68d9e426e3cb4ae4dff1fcd8e4a2c34b781bf7a822574a0d0aac8"
dependencies = [
"sct",
]
Allow limiting of values on derive(Gbnf) structs. With the new helper attribute #[gbnf_limit] on a field of a struct that has #[derive(Gbnf)], it is now possible to constrain the output of the LLM to a specific set of values for that field. This is extremely useful, for example, when asking the LLM to put a specific ID in a field. This commit also addresses numerous shortcomings of the original implementation of the derive macro. Deserialization of certain LLM responses currently broken as of this commit, due to different field names in the LLM output vs what serde expects (camelCase vs snake_case issues).
2024-02-07 11:01:47 +00:00
[[package]]
name = "darling"
version = "0.20.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fc5d6b04b3fd0ba9926f945895de7d806260a2d7431ba82e7edaecb043c4c6b8"
dependencies = [
"darling_core",
"darling_macro",
]
[[package]]
name = "darling_core"
version = "0.20.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "04e48a959bcd5c761246f5d090ebc2fbf7b9cd527a492b07a67510c108f1e7e3"
dependencies = [
"fnv",
"ident_case",
"proc-macro2",
"quote",
"strsim",
"syn 2.0.48",
]
[[package]]
name = "darling_macro"
version = "0.20.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1d1545d67a2149e1d93b7e5c7752dce5a7426eb5d1357ddcfd89336b94444f77"
dependencies = [
"darling_core",
"quote",
"syn 2.0.48",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "deranged"
version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
dependencies = [
"powerfmt",
]
[[package]]
name = "digest"
version = "0.10.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
dependencies = [
"block-buffer",
"crypto-common",
]
[[package]]
name = "dlv-list"
version = "0.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0688c2a7f92e427f44895cd63841bff7b29f8d7a1648b9e7e07a4a365b2e1257"
[[package]]
name = "dyn-clone"
version = "1.0.16"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "545b22097d44f8a9581187cdf93de7a71e4722bf51200cfaba810865b49a495d"
[[package]]
name = "either"
version = "1.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07"
[[package]]
name = "encoding_rs"
version = "0.8.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
dependencies = [
"cfg-if",
]
[[package]]
name = "equivalent"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
[[package]]
name = "errno"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.8"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"libc",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "eventsource-client"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b91e5ec5c794bbec5f639620f0bafe421b6d27dec66ac1ce3fdb6f009db3a6c"
dependencies = [
"futures",
"hyper",
"hyper-rustls",
"hyper-timeout",
"log",
"pin-project",
"rand",
"tokio",
]
[[package]]
name = "fastrand"
version = "2.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5"
[[package]]
name = "fd-lock"
version = "3.0.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef033ed5e9bad94e55838ca0ca906db0e043f517adda0c8b79c7a8c66c93c1b5"
dependencies = [
"cfg-if",
"rustix",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.48.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "flate2"
version = "1.0.28"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e"
dependencies = [
"crc32fast",
"miniz_oxide",
]
[[package]]
name = "fnv"
version = "1.0.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
[[package]]
name = "foreign-types"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
dependencies = [
"foreign-types-shared",
]
[[package]]
name = "foreign-types-shared"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
[[package]]
name = "form_urlencoded"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.2.1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"percent-encoding",
]
[[package]]
name = "funty"
version = "2.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
[[package]]
name = "futures"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"futures-channel",
"futures-core",
"futures-executor",
"futures-io",
"futures-sink",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-channel"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"futures-core",
"futures-sink",
]
[[package]]
name = "futures-core"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "futures-executor"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"futures-core",
"futures-task",
"futures-util",
]
[[package]]
name = "futures-io"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "futures-macro"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "futures-sink"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "futures-task"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "futures-util"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.30"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-macro",
"futures-sink",
"futures-task",
"memchr",
"pin-project-lite",
"pin-utils",
"slab",
]
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "gbnf"
version = "0.1.0"
dependencies = [
"auto_impl",
Allow limiting of values on derive(Gbnf) structs. With the new helper attribute #[gbnf_limit] on a field of a struct that has #[derive(Gbnf)], it is now possible to constrain the output of the LLM to a specific set of values for that field. This is extremely useful, for example, when asking the LLM to put a specific ID in a field. This commit also addresses numerous shortcomings of the original implementation of the derive macro. Deserialization of certain LLM responses currently broken as of this commit, due to different field names in the LLM output vs what serde expects (camelCase vs snake_case issues).
2024-02-07 11:01:47 +00:00
"convert_case",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"itertools 0.12.1",
"quote",
"serde",
"serde_derive",
"syn 2.0.48",
]
[[package]]
name = "gbnf_derive"
version = "0.1.0"
dependencies = [
"auto_impl",
Allow limiting of values on derive(Gbnf) structs. With the new helper attribute #[gbnf_limit] on a field of a struct that has #[derive(Gbnf)], it is now possible to constrain the output of the LLM to a specific set of values for that field. This is extremely useful, for example, when asking the LLM to put a specific ID in a field. This commit also addresses numerous shortcomings of the original implementation of the derive macro. Deserialization of certain LLM responses currently broken as of this commit, due to different field names in the LLM output vs what serde expects (camelCase vs snake_case issues).
2024-02-07 11:01:47 +00:00
"darling",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"gbnf",
"itertools 0.12.1",
Allow limiting of values on derive(Gbnf) structs. With the new helper attribute #[gbnf_limit] on a field of a struct that has #[derive(Gbnf)], it is now possible to constrain the output of the LLM to a specific set of values for that field. This is extremely useful, for example, when asking the LLM to put a specific ID in a field. This commit also addresses numerous shortcomings of the original implementation of the derive macro. Deserialization of certain LLM responses currently broken as of this commit, due to different field names in the LLM output vs what serde expects (camelCase vs snake_case issues).
2024-02-07 11:01:47 +00:00
"proc-macro2",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"quote",
"syn 2.0.48",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "generic-array"
version = "0.14.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
dependencies = [
"typenum",
"version_check",
]
[[package]]
name = "getopts"
version = "0.2.21"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "14dbbfd5c71d70241ecf9e6f13737f7b5ce823821063188d7e46c41d371eebd5"
dependencies = [
"unicode-width",
]
[[package]]
name = "getrandom"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.12"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "190092ea657667030ac6a35e305e62fc4dd69fd98ac98631e5d3a2b1575a12b5"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"cfg-if",
"js-sys",
"libc",
"wasi",
"wasm-bindgen",
]
[[package]]
name = "gimli"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.28.1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "h2"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.24"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "bb2c4422095b67ee78da96fbb51a4cc413b3b25883c7717ff7ca1ab31022c9c9"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"bytes",
"fnv",
"futures-core",
"futures-sink",
"futures-util",
"http",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"indexmap 2.2.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"slab",
"tokio",
"tokio-util",
"tracing",
]
[[package]]
name = "hashbrown"
version = "0.12.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
dependencies = [
"ahash 0.7.7",
]
[[package]]
name = "hashbrown"
version = "0.13.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e"
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"ahash 0.8.7",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "hashbrown"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.14.3"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "heck"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
[[package]]
name = "hermit-abi"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.4"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "5d3d0e0f38255e7fa3cf31335b3a56f05febd18025f4db5ef7a0cfb4f8da651f"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "hex"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
[[package]]
name = "http"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.11"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "8947b1a6fad4393052c7ba1f4cd97bed3e953a95c79c92ad9b051a04611d9fbb"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"bytes",
"fnv",
"itoa",
]
[[package]]
name = "http-body"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.6"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"bytes",
"http",
"pin-project-lite",
]
[[package]]
name = "httparse"
version = "1.8.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904"
[[package]]
name = "httpdate"
version = "1.0.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
[[package]]
name = "hyper"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.14.28"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"bytes",
"futures-channel",
"futures-core",
"futures-util",
"h2",
"http",
"http-body",
"httparse",
"httpdate",
"itoa",
"pin-project-lite",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"socket2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"tokio",
"tower-service",
"tracing",
"want",
]
[[package]]
name = "hyper-rustls"
version = "0.22.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5f9f7a97316d44c0af9b0301e65010573a853a9fc97046d7331d7f6bc0fd5a64"
dependencies = [
"ct-logs",
"futures-util",
"hyper",
"log",
"rustls",
"rustls-native-certs",
"tokio",
"tokio-rustls",
"webpki",
]
[[package]]
name = "hyper-timeout"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbb958482e8c7be4bc3cf272a766a2b0bf1a6755e7a6ae777f017a31d11b13b1"
dependencies = [
"hyper",
"pin-project-lite",
"tokio",
"tokio-io-timeout",
]
[[package]]
name = "hyper-tls"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d6183ddfa99b85da61a140bea0efc93fdf56ceaa041b37d553518030827f9905"
dependencies = [
"bytes",
"hyper",
"native-tls",
"tokio",
"tokio-native-tls",
]
[[package]]
name = "iana-time-zone"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.1.59"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "b6a67363e2aa4443928ce15e57ebae94fd8949958fd1223c4cfc0cd473ad7539"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"android_system_properties",
"core-foundation-sys",
"iana-time-zone-haiku",
"js-sys",
"wasm-bindgen",
"windows-core",
]
[[package]]
name = "iana-time-zone-haiku"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
dependencies = [
"cc",
]
Allow limiting of values on derive(Gbnf) structs. With the new helper attribute #[gbnf_limit] on a field of a struct that has #[derive(Gbnf)], it is now possible to constrain the output of the LLM to a specific set of values for that field. This is extremely useful, for example, when asking the LLM to put a specific ID in a field. This commit also addresses numerous shortcomings of the original implementation of the derive macro. Deserialization of certain LLM responses currently broken as of this commit, due to different field names in the LLM output vs what serde expects (camelCase vs snake_case issues).
2024-02-07 11:01:47 +00:00
[[package]]
name = "ident_case"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "idna"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.5.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"unicode-bidi",
"unicode-normalization",
]
[[package]]
name = "indexmap"
version = "1.9.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99"
dependencies = [
"autocfg",
"hashbrown 0.12.3",
"serde",
]
[[package]]
name = "indexmap"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.2.2"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "824b2ae422412366ba479e8111fd301f7b5faece8149317bb81925979a53f520"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"equivalent",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"hashbrown 0.14.3",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"serde",
]
[[package]]
name = "ipnet"
version = "2.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3"
[[package]]
name = "itertools"
version = "0.10.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
dependencies = [
"either",
]
[[package]]
name = "itertools"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.12.1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"either",
]
[[package]]
name = "itoa"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.10"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "js-sys"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.67"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "9a1d36f1235bc969acba30b7f5990b864423a6068a10f7c90ae8f0112e3a59d1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"wasm-bindgen",
]
[[package]]
name = "json5"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96b0db21af676c1ce64250b5f40f3ce2cf27e4e47cb91ed91eb6fe9350b430c1"
dependencies = [
"pest",
"pest_derive",
"serde",
]
[[package]]
name = "lazy_static"
version = "1.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
[[package]]
name = "libc"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.153"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "9c198f91728a82281a64e1f4f9eeb25d82cb32a5de251c6bd1b5154d63a8e7bd"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "linked-hash-map"
version = "0.5.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
[[package]]
name = "linux-raw-sys"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.13"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "01cda141df6706de531b6c46c3a33ecca755538219bd484262fa09410c13539c"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "lock_api"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.11"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"autocfg",
"scopeguard",
]
[[package]]
name = "log"
version = "0.4.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f"
[[package]]
name = "lz4_flex"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b8c72594ac26bfd34f2d99dfced2edfaddfe8a476e3ff2ca0eb293d925c4f83"
dependencies = [
"twox-hash",
]
[[package]]
name = "maybe-async"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.9"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "afc95a651c82daf7004c824405aa1019723644950d488571bd718e3ed84646ed"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "memchr"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.7.1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "memmap2"
version = "0.5.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327"
dependencies = [
"libc",
]
[[package]]
name = "mime"
version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
[[package]]
name = "minimal-lexical"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]
name = "miniz_oxide"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7"
dependencies = [
"adler",
]
[[package]]
name = "mio"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.8.10"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"libc",
"log",
"wasi",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.48.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "native-tls"
version = "0.2.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "07226173c32f2926027b63cce4bcd8076c3552846cbe7925f3aaffeac0a3b92e"
dependencies = [
"lazy_static",
"libc",
"log",
"openssl",
"openssl-probe",
"openssl-sys",
"schannel",
"security-framework",
"security-framework-sys",
"tempfile",
]
[[package]]
name = "nom"
version = "7.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
dependencies = [
"memchr",
"minimal-lexical",
]
[[package]]
name = "nu-ansi-term"
version = "0.49.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c073d3c1930d0751774acf49e66653acecb416c3a54c6ec095a9b11caddb5a68"
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.48.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "num-conv"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "num-traits"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "39e3200413f237f41ab11ad6d161bc7239c84dcb631773ccd7de3dfe4b5c267c"
dependencies = [
"autocfg",
]
[[package]]
name = "num_cpus"
version = "1.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43"
dependencies = [
"hermit-abi",
"libc",
]
[[package]]
name = "num_enum"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a015b430d3c108a207fd776d2e2196aaf8b1cf8cf93253e3a097ff3085076a1"
dependencies = [
"num_enum_derive",
]
[[package]]
name = "num_enum_derive"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6"
dependencies = [
"proc-macro-crate",
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "object"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.32.2"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"memchr",
]
[[package]]
name = "once_cell"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.19.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "openapiv3"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.0.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "cc02deea53ffe807708244e5914f6b099ad7015a207ee24317c22112e17d9c5c"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"indexmap 2.2.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"serde",
"serde_json",
]
[[package]]
name = "openssl"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.10.63"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "15c9d69dd87a29568d4d017cfe8ec518706046a05184e5aea92d0af890b803c8"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"bitflags 2.4.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"cfg-if",
"foreign-types",
"libc",
"once_cell",
"openssl-macros",
"openssl-sys",
]
[[package]]
name = "openssl-macros"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "openssl-probe"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf"
[[package]]
name = "openssl-sys"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.9.99"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "22e1bf214306098e4832460f797824c05d25aacdf896f64a985fb0fd992454ae"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"cc",
"libc",
"pkg-config",
"vcpkg",
]
[[package]]
name = "ordered-multimap"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ccd746e37177e1711c20dd619a1620f34f5c8b569c53590a72dedd5344d8924a"
dependencies = [
"dlv-list",
"hashbrown 0.12.3",
]
Look at people and items in a scene. Non-LLM coherence. Adds the ability to inspect people or items in a scene. Also technically props, but they are not first class entities (i.e. stored in DB with an ID), so the LLM will behave oddly if you attempt to look at a prop. Also adds the foundation of non-LLM + LLM command coherence to fix up LLM responses from LLM command execution. CommandEvents that are recognized as incoherent will attempt to be fixed by the command coherence layer. Currently only non-LLM coherence checks are done (normalizing IDs, making sure they are right, etc). Also many changes to command execution prompt to make it more intelligent and correct. Many foundational pieces for building actual game mechanics and in-depth coherence are also added.
2024-01-30 11:03:32 +00:00
[[package]]
name = "papergrid"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9ad43c07024ef767f9160710b3a6773976194758c7919b17e63b863db0bdf7fb"
dependencies = [
"bytecount",
"fnv",
"unicode-width",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "parking_lot"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
dependencies = [
"lock_api",
"parking_lot_core",
]
[[package]]
name = "parking_lot_core"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.9.9"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"cfg-if",
"libc",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"redox_syscall",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"smallvec",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-targets 0.48.5",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "pathdiff"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8835116a5c179084a830efb3adc117ab007512b535bc1a21c991d3b32a6b44dd"
[[package]]
name = "percent-encoding"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.3.1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "pest"
version = "2.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f200d8d83c44a45b21764d1916299752ca035d15ecd46faca3e9a2a2bf6ad06"
dependencies = [
"memchr",
"thiserror",
"ucd-trie",
]
[[package]]
name = "pest_derive"
version = "2.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bcd6ab1236bbdb3a49027e920e693192ebfe8913f6d60e294de57463a493cfde"
dependencies = [
"pest",
"pest_generator",
]
[[package]]
name = "pest_generator"
version = "2.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2a31940305ffc96863a735bef7c7994a00b325a7138fdbc5bda0f1a0476d3275"
dependencies = [
"pest",
"pest_meta",
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "pest_meta"
version = "2.7.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a7ff62f5259e53b78d1af898941cdcdccfae7385cf7d793a6e55de5d05bb4b7d"
dependencies = [
"once_cell",
"pest",
"sha2",
]
[[package]]
name = "pin-project"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.1.4"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "0302c4a0442c456bd56f841aee5c3bfd17967563f6fadc9ceb9f9c23cf3807e0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"pin-project-internal",
]
[[package]]
name = "pin-project-internal"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.1.4"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "266c042b60c9c76b8d53061e52b2e0d1116abc57cefc8c5cd671619a56ac3690"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "pin-project-lite"
version = "0.2.13"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58"
[[package]]
name = "pin-utils"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
[[package]]
name = "pkg-config"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.29"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "2900ede94e305130c13ddd391e0ab7cbaeb783945ae07a279c268cb05109c6cb"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "polodb_core"
version = "4.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fef3dbdf0bd44fa0d6e5630bc02f721f8238f7e58a0b50661c099fc759d355de"
dependencies = [
"bson",
"byteorder",
"crc64fast",
"getrandom",
"hashbrown 0.13.2",
"indexmap 1.9.3",
"js-sys",
"libc",
"lz4_flex",
"memmap2",
"num_enum",
"regex",
"serde",
"serde-wasm-bindgen",
"smallvec",
"thiserror",
"uuid",
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
"winapi",
]
[[package]]
name = "powerfmt"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
[[package]]
name = "ppv-lite86"
version = "0.2.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de"
[[package]]
name = "prettyplease"
version = "0.1.25"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6c8646e95016a7a6c4adea95bafa8a16baab64b583356217f2c85db4a39d9a86"
dependencies = [
"proc-macro2",
"syn 1.0.109",
]
[[package]]
name = "proc-macro-crate"
version = "1.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919"
dependencies = [
"once_cell",
"toml_edit",
]
Look at people and items in a scene. Non-LLM coherence. Adds the ability to inspect people or items in a scene. Also technically props, but they are not first class entities (i.e. stored in DB with an ID), so the LLM will behave oddly if you attempt to look at a prop. Also adds the foundation of non-LLM + LLM command coherence to fix up LLM responses from LLM command execution. CommandEvents that are recognized as incoherent will attempt to be fixed by the command coherence layer. Currently only non-LLM coherence checks are done (normalizing IDs, making sure they are right, etc). Also many changes to command execution prompt to make it more intelligent and correct. Many foundational pieces for building actual game mechanics and in-depth coherence are also added.
2024-01-30 11:03:32 +00:00
[[package]]
name = "proc-macro-error"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c"
dependencies = [
"proc-macro-error-attr",
"proc-macro2",
"quote",
"syn 1.0.109",
"version_check",
]
[[package]]
name = "proc-macro-error-attr"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869"
dependencies = [
"proc-macro2",
"quote",
"version_check",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "proc-macro2"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.78"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "e2422ad645d89c99f8f3e6b88a9fdeca7fabeac836b1002371c4367c8f984aae"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"unicode-ident",
]
[[package]]
name = "progenitor"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.5.0"
source = "git+https://github.com/oxidecomputer/progenitor#86b60220b88a2ca3629fb87acf8f83ff35f63aaa"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"progenitor-client",
"progenitor-impl",
"progenitor-macro",
"serde_json",
]
[[package]]
name = "progenitor-client"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.5.0"
source = "git+https://github.com/oxidecomputer/progenitor#86b60220b88a2ca3629fb87acf8f83ff35f63aaa"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"bytes",
"futures-core",
"percent-encoding",
"reqwest",
"serde",
"serde_json",
"serde_urlencoded",
]
[[package]]
name = "progenitor-impl"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.5.0"
source = "git+https://github.com/oxidecomputer/progenitor#86b60220b88a2ca3629fb87acf8f83ff35f63aaa"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"getopts",
"heck",
"http",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"indexmap 2.2.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"openapiv3",
"proc-macro2",
"quote",
"regex",
"schemars",
"serde",
"serde_json",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"thiserror",
"typify",
"unicode-ident",
]
[[package]]
name = "progenitor-macro"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.5.0"
source = "git+https://github.com/oxidecomputer/progenitor#86b60220b88a2ca3629fb87acf8f83ff35f63aaa"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"openapiv3",
"proc-macro2",
"progenitor-impl",
"quote",
"schemars",
"serde",
"serde_json",
"serde_tokenstream",
"serde_yaml",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "quote"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.35"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
]
[[package]]
name = "radium"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
[[package]]
name = "rand"
version = "0.8.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
dependencies = [
"libc",
"rand_chacha",
"rand_core",
]
[[package]]
name = "rand_chacha"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
dependencies = [
"ppv-lite86",
"rand_core",
]
[[package]]
name = "rand_core"
version = "0.6.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
dependencies = [
"getrandom",
]
[[package]]
name = "redox_syscall"
version = "0.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa"
dependencies = [
"bitflags 1.3.2",
]
[[package]]
name = "reedline"
version = "0.27.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "07046f804ccb26a6fa8b638f505ccd2a8b7702399a89b9640a0d40ecda49233d"
dependencies = [
"chrono",
"crossterm",
"fd-lock",
"itertools 0.10.5",
"nu-ansi-term",
"serde",
"strip-ansi-escapes",
"strum",
"strum_macros",
"thiserror",
"unicode-segmentation",
"unicode-width",
]
[[package]]
name = "regex"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.10.3"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"aho-corasick",
"memchr",
"regex-automata",
"regex-syntax",
]
[[package]]
name = "regex-automata"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.5"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"aho-corasick",
"memchr",
"regex-syntax",
]
[[package]]
name = "regex-syntax"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
[[package]]
name = "regress"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4ed9969cad8051328011596bf549629f1b800cf1731e7964b1eef8dfc480d2c2"
dependencies = [
"hashbrown 0.13.2",
"memchr",
]
[[package]]
name = "reqwest"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.11.24"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "c6920094eb85afde5e4a138be3f2de8bbdf28000f0029e72c45025a56b042251"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"async-compression",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"base64 0.21.7",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"bytes",
"encoding_rs",
"futures-core",
"futures-util",
"h2",
"http",
"http-body",
"hyper",
"hyper-tls",
"ipnet",
"js-sys",
"log",
"mime",
"native-tls",
"once_cell",
"percent-encoding",
"pin-project-lite",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"rustls-pemfile",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"serde",
"serde_json",
"serde_urlencoded",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"sync_wrapper",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"system-configuration",
"tokio",
"tokio-native-tls",
"tokio-util",
"tower-service",
"url",
"wasm-bindgen",
"wasm-bindgen-futures",
"wasm-streams",
"web-sys",
"winreg",
]
[[package]]
name = "ring"
version = "0.16.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
dependencies = [
"cc",
"libc",
"once_cell",
"spin",
"untrusted",
"web-sys",
"winapi",
]
[[package]]
name = "ron"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "88073939a61e5b7680558e6be56b419e208420c2adb92be54921fa6b72283f1a"
dependencies = [
"base64 0.13.1",
"bitflags 1.3.2",
"serde",
]
[[package]]
name = "rust-ini"
version = "0.18.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f6d5f2436026b4f6e79dc829837d467cc7e9a55ee40e750d716713540715a2df"
dependencies = [
"cfg-if",
"ordered-multimap",
]
[[package]]
name = "rustc-demangle"
version = "0.1.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76"
[[package]]
name = "rustix"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.38.31"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "6ea3e1a662af26cd7a3ba09c0297a31af215563ecf42817c98df621387f4e949"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"bitflags 2.4.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"errno",
"libc",
"linux-raw-sys",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "rustls"
version = "0.19.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "35edb675feee39aec9c99fa5ff985081995a06d594114ae14cbe797ad7b7a6d7"
dependencies = [
"base64 0.13.1",
"log",
"ring",
"sct",
"webpki",
]
[[package]]
name = "rustls-native-certs"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5a07b7c1885bd8ed3831c289b7870b13ef46fe0e856d288c30d9cc17d75a2092"
dependencies = [
"openssl-probe",
"rustls",
"schannel",
"security-framework",
]
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "rustls-pemfile"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c"
dependencies = [
"base64 0.21.7",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "rustversion"
version = "1.0.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4"
[[package]]
name = "ryu"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.16"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "schannel"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.1.23"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "fbc91545643bcf3a0bbb6569265615222618bdf33ce4ffbbd13c4bbd4c093534"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "schemars"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.8.16"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "45a28f4c49489add4ce10783f7911893516f15afe45d015608d41faca6bc4d29"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"chrono",
"dyn-clone",
"schemars_derive",
"serde",
"serde_json",
"uuid",
]
[[package]]
name = "schemars_derive"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.8.16"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "c767fd6fa65d9ccf9cf026122c1b555f2ef9a4f0cea69da4d7dbc3e258d30967"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
"serde_derive_internals",
"syn 1.0.109",
]
[[package]]
name = "scopeguard"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
[[package]]
name = "sct"
version = "0.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b362b83898e0e69f38515b82ee15aa80636befe47c3b6d3d89a911e78fc228ce"
dependencies = [
"ring",
"untrusted",
]
[[package]]
name = "security-framework"
version = "2.9.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05b64fb303737d99b81884b2c63433e9ae28abebe5eb5045dcdd175dc2ecf4de"
dependencies = [
"bitflags 1.3.2",
"core-foundation",
"core-foundation-sys",
"libc",
"security-framework-sys",
]
[[package]]
name = "security-framework-sys"
version = "2.9.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e932934257d3b408ed8f30db49d85ea163bfe74961f017f405b025af298f0c7a"
dependencies = [
"core-foundation-sys",
"libc",
]
[[package]]
name = "serde"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.196"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"serde_derive",
]
[[package]]
name = "serde-wasm-bindgen"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f3b143e2833c57ab9ad3ea280d21fd34e285a42837aeb0ee301f4f41890fa00e"
dependencies = [
"js-sys",
"serde",
"wasm-bindgen",
]
[[package]]
name = "serde_bytes"
version = "0.11.14"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8b8497c313fd43ab992087548117643f6fcd935cbf36f176ffda0aacf9591734"
dependencies = [
"serde",
]
[[package]]
name = "serde_derive"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.196"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "serde_derive_internals"
version = "0.26.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "85bf8229e7920a9f636479437026331ce11aa132b4dde37d121944a44d6e5f3c"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]]
name = "serde_json"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.113"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"indexmap 2.2.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"itoa",
"ryu",
"serde",
]
[[package]]
name = "serde_qs"
version = "0.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8cac3f1e2ca2fe333923a1ae72caca910b98ed0630bb35ef6f8c8517d6e81afa"
dependencies = [
"percent-encoding",
"serde",
"thiserror",
]
[[package]]
name = "serde_tokenstream"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a00ffd23fd882d096f09fcaae2a9de8329a328628e86027e049ee051dc1621f"
dependencies = [
"proc-macro2",
"quote",
"serde",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
dependencies = [
"form_urlencoded",
"itoa",
"ryu",
"serde",
]
[[package]]
name = "serde_yaml"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.9.31"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "adf8a49373e98a4c5f0ceb5d05aa7c648d75f63774981ed95b7c7443bbd50c6e"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"indexmap 2.2.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"itoa",
"ryu",
"serde",
"unsafe-libyaml",
]
[[package]]
name = "sha2"
version = "0.10.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8"
dependencies = [
"cfg-if",
"cpufeatures",
"digest",
]
[[package]]
name = "signal-hook"
version = "0.3.17"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8621587d4798caf8eb44879d42e56b9a93ea5dcd315a6487c357130095b62801"
dependencies = [
"libc",
"signal-hook-registry",
]
[[package]]
name = "signal-hook-mio"
version = "0.2.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "29ad2e15f37ec9a6cc544097b78a1ec90001e9f71b81338ca39f430adaca99af"
dependencies = [
"libc",
"mio",
"signal-hook",
]
[[package]]
name = "signal-hook-registry"
version = "1.4.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1"
dependencies = [
"libc",
]
[[package]]
name = "slab"
version = "0.4.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67"
dependencies = [
"autocfg",
]
[[package]]
name = "smallvec"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.13.1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "smawk"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b7c388c1b5e93756d0c740965c41e8822f866621d41acbdf6336a6a168f8840c"
[[package]]
name = "socket2"
version = "0.5.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9"
dependencies = [
"libc",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.48.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "spin"
version = "0.5.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
[[package]]
name = "static_assertions"
version = "1.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
[[package]]
name = "strip-ansi-escapes"
version = "0.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55ff8ef943b384c414f54aefa961dd2bd853add74ec75e7ac74cf91dba62bcfa"
dependencies = [
"vte",
]
Allow limiting of values on derive(Gbnf) structs. With the new helper attribute #[gbnf_limit] on a field of a struct that has #[derive(Gbnf)], it is now possible to constrain the output of the LLM to a specific set of values for that field. This is extremely useful, for example, when asking the LLM to put a specific ID in a field. This commit also addresses numerous shortcomings of the original implementation of the derive macro. Deserialization of certain LLM responses currently broken as of this commit, due to different field names in the LLM output vs what serde expects (camelCase vs snake_case issues).
2024-02-07 11:01:47 +00:00
[[package]]
name = "strsim"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "73473c0e59e6d5812c5dfe2a064a6444949f089e20eec9a2e5506596494e4623"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "strum"
version = "0.25.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
dependencies = [
"strum_macros",
]
[[package]]
name = "strum_macros"
version = "0.25.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
dependencies = [
"heck",
"proc-macro2",
"quote",
"rustversion",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "syn"
version = "1.0.109"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
[[package]]
name = "syn"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.0.48"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
"unicode-ident",
]
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "sync_wrapper"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2047c6ded9c721764247e62cd3b03c09ffc529b2ba5b10ec482ae507a4a70160"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "system-configuration"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7"
dependencies = [
"bitflags 1.3.2",
"core-foundation",
"system-configuration-sys",
]
[[package]]
name = "system-configuration-sys"
version = "0.5.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9"
dependencies = [
"core-foundation-sys",
"libc",
]
Look at people and items in a scene. Non-LLM coherence. Adds the ability to inspect people or items in a scene. Also technically props, but they are not first class entities (i.e. stored in DB with an ID), so the LLM will behave oddly if you attempt to look at a prop. Also adds the foundation of non-LLM + LLM command coherence to fix up LLM responses from LLM command execution. CommandEvents that are recognized as incoherent will attempt to be fixed by the command coherence layer. Currently only non-LLM coherence checks are done (normalizing IDs, making sure they are right, etc). Also many changes to command execution prompt to make it more intelligent and correct. Many foundational pieces for building actual game mechanics and in-depth coherence are also added.
2024-01-30 11:03:32 +00:00
[[package]]
name = "tabled"
version = "0.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c998b0c8b921495196a48aabaf1901ff28be0760136e31604f7967b0792050e"
dependencies = [
"papergrid",
"tabled_derive",
"unicode-width",
]
[[package]]
name = "tabled_derive"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4c138f99377e5d653a371cdad263615634cfc8467685dfe8e73e2b8e98f44b17"
dependencies = [
"heck",
"proc-macro-error",
"proc-macro2",
"quote",
"syn 1.0.109",
]
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "tap"
version = "1.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
[[package]]
name = "tempfile"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "3.9.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "01ce4141aa927a6d1bd34a041795abd0db1cccba5d5f24b009f694bdf3a1f3fa"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"cfg-if",
"fastrand",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"redox_syscall",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"rustix",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "textwrap"
version = "0.16.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "222a222a5bfe1bba4a77b45ec488a741b3cb8872e5e499451fd7d0129c9c7c3d"
dependencies = [
"smawk",
"unicode-linebreak",
"unicode-width",
]
[[package]]
name = "thiserror"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.56"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "d54378c645627613241d077a3a79db965db602882668f9136ac42af9ecb730ad"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"thiserror-impl",
]
[[package]]
name = "thiserror-impl"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.0.56"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "fa0faa943b50f3db30a20aa7e265dbc66076993efed8463e8de414e5d06d3471"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "time"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.32"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "fe80ced77cbfb4cb91a94bf72b378b4b6791a0d9b7f09d0be747d1bdff4e68bd"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"deranged",
"itoa",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"num-conv",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"powerfmt",
"serde",
"time-core",
"time-macros",
]
[[package]]
name = "time-core"
version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3"
[[package]]
name = "time-macros"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.17"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "7ba3a3ef41e6672a2f0f001392bb5dcd3ff0a9992d618ca761a11c3121547774"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"num-conv",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"time-core",
]
[[package]]
name = "tinyvec"
version = "1.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
dependencies = [
"tinyvec_macros",
]
[[package]]
name = "tinyvec_macros"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
[[package]]
name = "tokio"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "1.36.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "61285f6515fa018fb2d1e46eb21223fff441ee8db5d0f1435e8ab4f5cdb80931"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"backtrace",
"bytes",
"libc",
"mio",
"num_cpus",
"parking_lot",
"pin-project-lite",
"signal-hook-registry",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"socket2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"tokio-macros",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.48.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "tokio-io-timeout"
version = "1.2.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "30b74022ada614a1b4834de765f9bb43877f910cc8ce4be40e89042c9223a8bf"
dependencies = [
"pin-project-lite",
"tokio",
]
[[package]]
name = "tokio-macros"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.2.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "tokio-native-tls"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbae76ab933c85776efabc971569dd6119c580d8f5d448769dec1764bf796ef2"
dependencies = [
"native-tls",
"tokio",
]
[[package]]
name = "tokio-rustls"
version = "0.22.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc6844de72e57df1980054b38be3a9f4702aba4858be64dd700181a8a6d0e1b6"
dependencies = [
"rustls",
"tokio",
"webpki",
]
[[package]]
name = "tokio-util"
version = "0.7.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15"
dependencies = [
"bytes",
"futures-core",
"futures-sink",
"pin-project-lite",
"tokio",
"tracing",
]
[[package]]
name = "toml"
version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f4f7f0dd8d50a853a531c426359045b1998f04219d88799810762cd4ad314234"
dependencies = [
"serde",
]
[[package]]
name = "toml_datetime"
version = "0.6.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1"
[[package]]
name = "toml_edit"
version = "0.19.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421"
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"indexmap 2.2.2",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"toml_datetime",
"winnow",
]
[[package]]
name = "tower-service"
version = "0.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52"
[[package]]
name = "tracing"
version = "0.1.40"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef"
dependencies = [
"pin-project-lite",
"tracing-core",
]
[[package]]
name = "tracing-core"
version = "0.1.32"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54"
dependencies = [
"once_cell",
]
[[package]]
name = "try-lock"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.5"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "twox-hash"
version = "1.6.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97fee6b57c6a41524a810daee9286c02d7752c4253064d0b05472833a438f675"
dependencies = [
"cfg-if",
"static_assertions",
]
[[package]]
name = "typed-builder"
version = "0.10.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "89851716b67b937e393b3daa8423e67ddfc4bbbf1654bcf05488e95e0828db0c"
dependencies = [
"proc-macro2",
"quote",
"syn 1.0.109",
]
[[package]]
name = "typenum"
version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"
[[package]]
name = "typify"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.0.15"
source = "git+https://github.com/oxidecomputer/typify#1f97f167923f001818d461b1286f8a5242abf8b1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"typify-impl",
"typify-macro",
]
[[package]]
name = "typify-impl"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.0.15"
source = "git+https://github.com/oxidecomputer/typify#1f97f167923f001818d461b1286f8a5242abf8b1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"heck",
"log",
"proc-macro2",
"quote",
"regress",
"schemars",
"serde_json",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"thiserror",
"unicode-ident",
]
[[package]]
name = "typify-macro"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.0.15"
source = "git+https://github.com/oxidecomputer/typify#1f97f167923f001818d461b1286f8a5242abf8b1"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
"schemars",
"serde",
"serde_json",
"serde_tokenstream",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"typify-impl",
]
[[package]]
name = "ucd-trie"
version = "0.1.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed646292ffc8188ef8ea4d1e0e0150fb15a5c2e12ad9b8fc191ae7a8a7f3c4b9"
[[package]]
name = "uclient"
version = "0.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51d45925a61653ac70f0588562067041ea522938898c912b0887c6dba8072ea7"
dependencies = [
"async-trait",
"http",
"maybe-async",
"reqwest",
"thiserror",
"url",
]
[[package]]
name = "unicode-bidi"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.15"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "unicode-ident"
version = "1.0.12"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
[[package]]
name = "unicode-linebreak"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3b09c83c3c29d37506a3e260c08c03743a6bb66a9cd432c6934ab501a190571f"
[[package]]
name = "unicode-normalization"
version = "0.1.22"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
dependencies = [
"tinyvec",
]
[[package]]
name = "unicode-segmentation"
version = "1.10.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1dd624098567895118886609431a7c3b8f516e41d30e0643f03d94592a147e36"
[[package]]
name = "unicode-width"
version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85"
[[package]]
name = "unsafe-libyaml"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.10"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "ab4c90930b95a82d00dc9e9ac071b4991924390d46cbd0dfe566148667605e4b"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "untrusted"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
[[package]]
name = "url"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "2.5.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"form_urlencoded",
"idna",
"percent-encoding",
]
[[package]]
name = "utf8parse"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "711b9620af191e0cdc7468a8d14e709c3dcdb115b36f838e601583af800a370a"
[[package]]
name = "uuid"
version = "1.6.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560"
dependencies = [
"atomic",
"getrandom",
"rand",
"serde",
"wasm-bindgen",
]
[[package]]
name = "vcpkg"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
[[package]]
name = "version_check"
version = "0.9.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
[[package]]
name = "vte"
version = "0.11.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f5022b5fbf9407086c180e9557be968742d839e68346af7792b8592489732197"
dependencies = [
"utf8parse",
"vte_generate_state_changes",
]
[[package]]
name = "vte_generate_state_changes"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d257817081c7dffcdbab24b9e62d2def62e2ff7d00b1c20062551e6cccc145ff"
dependencies = [
"proc-macro2",
"quote",
]
[[package]]
name = "want"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e"
dependencies = [
"try-lock",
]
[[package]]
name = "wasi"
version = "0.11.0+wasi-snapshot-preview1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
[[package]]
name = "wasm-bindgen"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.90"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "b1223296a201415c7fad14792dbefaace9bd52b62d33453ade1c5b5f07555406"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"cfg-if",
"wasm-bindgen-macro",
]
[[package]]
name = "wasm-bindgen-backend"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.90"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "fcdc935b63408d58a32f8cc9738a0bffd8f05cc7c002086c6ef20b7312ad9dcd"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"bumpalo",
"log",
"once_cell",
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-futures"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.40"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "bde2032aeb86bdfaecc8b261eef3cba735cc426c1f3a3416d1e0791be95fc461"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"cfg-if",
"js-sys",
"wasm-bindgen",
"web-sys",
]
[[package]]
name = "wasm-bindgen-macro"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.90"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "3e4c238561b2d428924c49815533a8b9121c664599558a5d9ec51f8a1740a999"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"quote",
"wasm-bindgen-macro-support",
]
[[package]]
name = "wasm-bindgen-macro-support"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.90"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "bae1abb6806dc1ad9e560ed242107c0f6c84335f1749dd4e8ddb012ebd5e25a7"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
"wasm-bindgen-backend",
"wasm-bindgen-shared",
]
[[package]]
name = "wasm-bindgen-shared"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.2.90"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "4d91413b1c31d7539ba5ef2451af3f0b833a005eb27a631cec32bc0635a8602b"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "wasm-streams"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.4.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "b65dc4c90b63b118468cf747d8bf3566c1913ef60be765b5730ead9e0a3ba129"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"futures-util",
"js-sys",
"wasm-bindgen",
"wasm-bindgen-futures",
"web-sys",
]
[[package]]
name = "web-sys"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.3.67"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "58cd2333b6e0be7a39605f0e255892fd7418a682d8da8fe042fe25128794d2ed"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"js-sys",
"wasm-bindgen",
]
[[package]]
name = "webpki"
version = "0.21.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b8e38c0608262c46d4a56202ebabdeb094cef7e560ca7a226c6bf055188aa4ea"
dependencies = [
"ring",
"untrusted",
]
[[package]]
name = "winapi"
version = "0.3.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
dependencies = [
"winapi-i686-pc-windows-gnu",
"winapi-x86_64-pc-windows-gnu",
]
[[package]]
name = "winapi-i686-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
[[package]]
name = "winapi-x86_64-pc-windows-gnu"
version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "windows-core"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.52.0"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "33ab640c8d7e35bf8ba19b884ba838ceb4fba93a4e8c65a9059d08afcfc683d9"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-targets 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "windows-sys"
version = "0.48.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-targets 0.48.5",
]
[[package]]
name = "windows-sys"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
dependencies = [
"windows-targets 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "windows-targets"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
dependencies = [
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows_aarch64_gnullvm 0.48.5",
"windows_aarch64_msvc 0.48.5",
"windows_i686_gnu 0.48.5",
"windows_i686_msvc 0.48.5",
"windows_x86_64_gnu 0.48.5",
"windows_x86_64_gnullvm 0.48.5",
"windows_x86_64_msvc 0.48.5",
]
[[package]]
name = "windows-targets"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd"
dependencies = [
"windows_aarch64_gnullvm 0.52.0",
"windows_aarch64_msvc 0.52.0",
"windows_i686_gnu 0.52.0",
"windows_i686_msvc 0.52.0",
"windows_x86_64_gnu 0.52.0",
"windows_x86_64_gnullvm 0.52.0",
"windows_x86_64_msvc 0.52.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "windows_aarch64_gnullvm"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "windows_aarch64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "windows_aarch64_msvc"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "windows_i686_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "windows_i686_gnu"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "windows_i686_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "windows_i686_msvc"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "windows_x86_64_gnu"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "windows_x86_64_gnu"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "windows_x86_64_gnullvm"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "windows_x86_64_msvc"
version = "0.48.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
[[package]]
name = "windows_x86_64_msvc"
version = "0.52.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
[[package]]
name = "winnow"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.5.36"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "818ce546a11a9986bc24f93d0cdf38a8a1a400f1473ea8c82e59f6e0ffab9249"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"memchr",
]
[[package]]
name = "winreg"
version = "0.50.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
dependencies = [
"cfg-if",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"windows-sys 0.48.0",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]
[[package]]
name = "wyz"
version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
dependencies = [
"tap",
]
[[package]]
name = "yaml-rust"
version = "0.4.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "56c1936c4cc7a1c9ab21a1ebb602eb942ba868cbd44a99cb7cdc5892335e1c85"
dependencies = [
"linked-hash-map",
]
[[package]]
name = "zerocopy"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.7.32"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"zerocopy-derive",
]
[[package]]
name = "zerocopy-derive"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
version = "0.7.32"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
source = "registry+https://github.com/rust-lang/crates.io-index"
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
dependencies = [
"proc-macro2",
"quote",
Implement derive macro to convert structs to GBNF rules. This is the initial implementation of a derive macro implementation that converts structs into GBNF grammars. This simplies the code by allowing us to get rid of all the hardcoded GBNF strings, prevents errors from manually editing or copying said strings, and other benefits. The main purpose of this implementation is to lay the foundation for generating hyper-specific GBNF rules that will allow us to limit LLM output to specific UUIDs. LLM can't generate a weird response for an exit or entity ID if it is only allowed to generate a specific list of UUIDs in its response.
2024-02-01 11:41:08 +00:00
"syn 2.0.48",
Initial commit of opening the AI game code. Now that it is somewhat presentable.
2023-11-07 12:53:42 +00:00
]