Keep model guides concise and use the Cactus package

README.md

@@ -1,5 +1,5 @@
 ---
-library_name: cactus-needle
+library_name: cactus-compute
 pipeline_tag: text-generation
 license: apache-2.0
 tags:
@@ -11,114 +11,38 @@ tags:
   - webassembly
 ---
 
-![Needle](assets/banner.svg)
+![Needle 3](assets/banner.svg)
 
-A foundation model for mobiles, wearables, robots, smart home, automotive and microcontrollers. The whole model is a single 8-29 MB file, and we trade general chat capacity to beat models 10x its size on mobile tool calls and match 2-3x bigger models on extraction.
+# Needle 3
 
-Needle does three jobs, all of them on the device:
-
-- **Tool calls**: given the functions your app exposes, Needle picks the right ones and fills every argument from what the user said. Ask for two things and you get two calls in order; ask for something no tool covers and you get an empty list, not a guess.
-- **Structured extraction**: declare a shape, hand over messy text, get typed fields back: an invoice, a booking, a notification, a form. The decode grammar guarantees the output parses, and extraction generalises to classification.
-- **Text embedding**: the same model returns a vector for a sentence, so an app can search, match and route locally.
-
-The same engine also runs [Whistle](https://huggingface.co/Cactus-Compute/whistle), our 16.9 MB speech-to-text model in seven languages. Load `whistle.cact` beside `needle3.cact` and the one binary transcribes a clip on its own, or answers it against your tools in a single call and returns the calls and the transcript in one JSON object.
-
-## Model
-
-![Needle 3 at a glance](assets/model.svg)
-
-Needle 3 is a Laddered Simple Attention Network, our small-model recipe: a Monarch Hadamard MLP in place of the FFN, GQA attention with causal conv taps, engram n-gram memory read by gather, and multi-lane hyper-connections, trained so that every depth from 2 to 20 layers is a deployable model. Most of its parameters sit in the engram, so the 121M model does the arithmetic of a 50M one. The weights are compressed to CQ2-bit with Cactus Quants; a byte-level grammar compiled from your schemas constrains every token, and every response carries a calibrated confidence score from a learned head. The architecture diagram is on the [release page](https://cactuscompute.com/needle). The repo holds the 20-layer `needle3.cact`, the `needle3.safetensors` checkpoint to fine-tune, and an engine per platform.
-
-## Benchmarks
-
-Tool calling is exact-match accuracy on the full test splits, extraction is field micro-F1 on the full test splits.
-
-![Needle 3 against baselines on six benchmarks](assets/benchmarks.svg)
-
-The interactive frontier plot, the architecture and the fine-tuning results are at [cactuscompute.com/needle](https://cactuscompute.com/needle).
+An on-device model for tool calling, structured extraction and text embeddings.
+See the [Needle website](https://cactuscompute.com/needle) for model details, benchmarks and the browser demo.
 
 ## Get started
 
 ```sh
-pip install cactus-needle
+pip install -U cactus-compute
 ```
 
-Try it in the browser at [cactuscompute.com/needle](https://cactuscompute.com/needle); the Python package and the source are on [GitHub](https://github.com/cactus-compute/needle).
-
 ```python
-import needle
+import cactus
 
-@needle.tool
+@cactus.tool
 def get_weather(city: str):
     "Get the current weather for a city."
     return {"city": city, "temp_c": 27, "sky": "clear"}
 
-agent = needle.Needle(tools=[get_weather])
-print(agent.run("what's it like in Lagos right now?")["results"])
-# [{'city': 'Lagos', 'temp_c': 27, 'sky': 'clear'}]
+with cactus.Cactus(tools=[get_weather]) as agent:
+    print(agent.run("What's the weather in Lagos?")["results"])
 ```
 
-Every turn returns one JSON object with `function_calls`, the model's `reasoning` and a calibrated `confidence`; an off-topic request returns an empty list rather than a guess. The engine and the weights are fetched from this repo once and cached.
+The package downloads and caches the engine and weights on first use.
+This repository provides `needle3.cact` and `checkpoints/needle3.safetensors`.
+[Runtime binaries and supported platforms](https://huggingface.co/Cactus-Compute/cactus) live in the Cactus repository.
 
 ## Guides
 
-- [How to design tools for Needle 3](https://cactuscompute.com/blog/designing-tools-for-needle): one tool per action, names users would say, formats in descriptions, constraints in the grammar, triggers.
-- [Leveraging Needle's confidence](https://cactuscompute.com/blog/needle-confidence): what the score measures, what the engine withholds, and routing on act, confirm or refuse.
-- [Structured JSON extraction with Needle](https://cactuscompute.com/blog/structured-extraction-with-needle): the record as the only tool, typed results, classification with enums.
-- [Fine-tuning Needle](https://cactuscompute.com/blog/finetuning-needle): the data format, the commands, reading the loss, sizing the dataset.
-- [Needle Python docs](https://cactuscompute.com/blog/needle-python-docs): the API, the response shape, the behaviour contract, system facts, tool retrieval, offline devices, environments, the CLI.
-- [What devices are supported on Needle](https://cactuscompute.com/blog/needle-supported-devices): every platform folder, the CLI runner, the C API, the browser, WASI, air-gapped setup.
-- [The .cact format](https://cactuscompute.com/blog/cact-format): the file the engine maps and reads in place, Cactus Quants at 2.125 bits per weight, and how to parse it yourself.
-- [Porting Needle 3](https://cactuscompute.com/blog/porting-needle): notes for writing your own runtime, the oracle to test against, the tensor order the container promises, the prompt on the wire, the ladder rule, retrieval with `needle_embed`.
-
-## Customisation
-
-Needle was designed to be customised. Its capacity is a ladder, and a subnetwork as small as 2 layers, fine-tuned on one product's tools, runs optimally on devices far smaller than the full model needs. Fine-tuning on DroidCall lifts every subnetwork by 18 to 36 points, and from 4 layers up the tuned subnetwork passes DeepSeek V4 Flash, starting at 29M parameters.
-
-![Every subnetwork before and after fine-tuning on DroidCall and on Mobile Actions](assets/finetune.svg)
-
-The Python package fine-tunes with LoRA on the frozen base at the full 20 layers, then `needle build [--layers N]` merges the adapter, slices any subnetwork from 2 to 20 layers and exports a 4-bit `.cact` that runs on the same engine. The 2-bit post-training and quantisation behind the shipped model, enriched with Cactus proprietary datasets, run on the [Cactus Platform](https://cactuscompute.com/dashboard).
-
-## Deploy
-
-Every platform folder in this repo holds an engine that loads `needle3.cact` at start. `needle build --platform <folder> [--layers N]` fetches the engine and header and puts the weights beside them at any depth, or download the folder here:
-
-![One engine per platform folder](assets/deploy.svg)
-
-```sh
-./needle --model needle3.cact --tools tools.json --prompt "dim the living room to 30"
-./needle --model needle3.cact --tools tools.json --serve
-
-# speech to text, live from a stream, and speech straight to tool calls
-./needle --model whistle.cact --audio clip.wav
-./needle --model whistle.cact --audio talk.wav --audio-stream
-./needle --model needle3.cact --model whistle.cact --tools tools.json --audio clip.wav
-```
-
-Tool schemas share the model context with the system prompt and conversation.
-`needle_init` returns the tokenized static-prefix length on success and fails
-when that prefix does not fit the model context. In the C API, call
-`needle_last_error()` after a negative return to get the measured prefix tokens
-and context limit. Reduce tool descriptions/schema text, split large catalogues,
-or declare more than five tools so Needle can keep only retrieved tools in the
-per-turn prefix. At completion time, `max_new_tokens` also reserves context room,
-so larger generation caps leave less space for the current turn and history.
-
-The [devices guide](https://cactuscompute.com/blog/needle-supported-devices) covers the runner flags, the C API, the WASI component and air-gapped setup.
-
-## Citation
-
-Needle 3 is built by the Cactus Compute team. If you use it in your work, please cite:
-
-```bibtex
-@misc{needle3_2026,
-  title        = {Needle: Foundation Tool-Calling Model for Tiny Devices},
-  author       = {Ndubuaku, Henry and Mosoyan, Karen and Mroz, Jakub and Cylich, Noah and
-                  Kumar, Satyajit and Sandhu, Parkirat and Shemet, Roman and Lee, Justin H.},
-  year         = {2026},
-  organization = {Cactus Compute, Inc.},
-  howpublished = {\url{https://github.com/cactus-compute/needle}}
-}
-```
-
-Reach out on founders@cactuscompute.com for partnerships, collaborations, synergies and deploying Needle in your product.
+- [Python API](https://cactuscompute.com/blog/needle-python-docs)
+- [Designing tools](https://cactuscompute.com/blog/designing-tools-for-needle) and [structured extraction](https://cactuscompute.com/blog/structured-extraction-with-needle)
+- [Fine-tuning](https://cactuscompute.com/blog/finetuning-needle)
+- [Source code](https://github.com/cactus-compute/cactus)

android-arm64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7aa6de6132a22bf45f5e903425feb66f159ad46f47fa558921bc4fd02c3a2fa0
-size 2177676

android-arm64/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:02a044e15489e19fa9f4f1cd1d5943d39dc0eefc08e0ba99d36279daf2351d46
-size 1586416

android-arm64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

android-armv7/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9f559a287b201c213e5c753d3cd1076a1849c73f94b445c85d11e4969422a135
-size 1700760

android-armv7/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8de71d0a00538ff3a64c2023f9d27121148295e50d414de284ac86586336127f
-size 967396

android-armv7/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

android-riscv64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a8eb2313c04b113b774794cfe0aa5361ecdc6f17bc4930deebbb1b924a891a8e
-size 5092414

android-riscv64/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7bdf932bd9eed6c2f49d5b83e6c3061766b49738ddfeb8a88b3d113b318630ab
-size 1431792

android-riscv64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

ios-arm64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:3e931f1d52319c1396901f3a16244ea47776d18acbf28543b62da408de45158a
-size 1501688

ios-arm64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

ios-sim-arm64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:75f836ada53fc55cd27a30e0edaea8bf5dcbcca6e30c9f0202fa192db20cea80
-size 1535472

ios-sim-arm64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

linux-arm64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:d54f0d83963c56eb79181929827c9f9ff405891d50cd12974c2b0f6485dd07af
-size 2024824

linux-arm64/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a7dd07f740763507edbca760dc7e7065b6da6b6bd6c3a05288ca974f14ce0fcb
-size 1439720

linux-arm64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

linux-armv7/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:972ce9802664307b681ef39dd86e0aa0164b4c3380d195476fe9e954b7804130
-size 1783478

linux-armv7/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1200e2b2d5005f969c30f321df72f0eff24b51a2862059b666da3f2dfef9ad2f
-size 1247772

linux-armv7/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

linux-mipsel/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:6f071b386e187b3b4905274f67e026d3ccecc3e2bebf7d49bd4d31616e593d6a
-size 1689382

linux-mipsel/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:b3d6abd16a1ba41870c1e4a1134cf4ffc0060eb66e9181e180882008063fe549
-size 1745296

linux-mipsel/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

linux-riscv64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:e0bb8e19fae59b0f969c5fad999a020817f8d2081773329c9651f7701f9e4dfa
-size 1939344

linux-riscv64/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:c87d816358cefbd12a2dd33ea8cc0767a9b361a1a1ed138eaf3006ed3845d5b2
-size 1186320

linux-riscv64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

linux-x86_64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:2f281877e24fed2658187a32d9a26e74c32d4f273ac9a2b36180b3a6e85942da
-size 2204068

linux-x86_64/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:77cd35ee75c53df8532b397e11ed7cf94a45d89a9f14f50881fd9c68ba54a2d0
-size 1550176

linux-x86_64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

macos-arm64/libneedle.a

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7d1368a4a42a745aba055f310913c3ed6d929dee98a89dcb955b9032b2335700
-size 1534472

macos-arm64/needle

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:0a480f7e01d1fcf9df2e6dbc29af29411406720a5c5cb73024fcd6d16aa25b60
-size 1107096

macos-arm64/needle.h

@@ -1,122 +0,0 @@
-#ifndef NEEDLE_H
-#define NEEDLE_H
-
-#ifndef NEEDLE_API
-#define NEEDLE_API __attribute__((visibility("default")))
-#endif
-
-#define NEEDLE_TEXT 1
-#define NEEDLE_SPEECH 2
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* One process-global, non-thread-safe model per kind, text and speech.
-   Negative returns indicate failure; call needle_last_error() for the specific
-   reason. needle_load reads whichever kind the .cact holds and keeps the other,
-   so a build with both models takes one call per model. */
-NEEDLE_API int needle_load(
-    const unsigned char* cact,
-    unsigned long long n
-);
-
-/* NEEDLE_TEXT, NEEDLE_SPEECH or both, for the models this process has loaded. */
-NEEDLE_API int needle_models(void);
-
-/* Last process-global error, owned by the runtime and valid until the next API call. */
-NEEDLE_API const char* needle_last_error(void);
-
-/* needle_init returns the tokenized static-prefix length on success. It can fail
-   when the system prompt plus statically-declared tools exceed the context
-   window, and reports the measured token count when it does. */
-NEEDLE_API int needle_init(
-    const char* system_prompt,
-    const char* tools_json,
-    const char* tool_index_path
-);
-
-/* Answers text or speech: exactly one of input and pcm is non-null. Given pcm,
-   the engine transcribes the clip with the loaded speech model, answers the
-   transcript, and merges the speech fields into the same JSON object under an
-   audio_ prefix. needle_set_audio chooses how that transcription runs. */
-NEEDLE_API int needle_complete(
-    const char* input,
-    const float* pcm,
-    int samples,
-    int max_new_tokens,
-    char* out,
-    int out_capacity
-);
-
-/* Language, keywords and word timestamps for the transcription needle_complete
-   runs for itself, with the meanings they have in needle_transcribe. The
-   strings are copied. Defaults: detect the language, no keywords, no times. */
-NEEDLE_API void needle_set_audio(
-    const char* language,
-    const char* keywords,
-    int word_timestamps
-);
-
-NEEDLE_API void needle_reset(void);
-
-/* Transcribes 16 kHz mono float PCM in [-1, 1] of any length and returns the
-   number of tokens in the transcript. Up to 30 s runs as one pass; longer audio
-   runs as consecutive 30 s windows, each decoded once and cut at its last
-   sentence end, with word times counted from the start of the clip. language is "en", "de", "fr", "es", "it", "nl" or
-   "pl", or NULL to detect it. keywords is NULL or newline-separated words and
-   phrases for keyword biasing. out receives JSON with the transcript, the
-   language used, the milliseconds to the first token and the decoder's tokens
-   per second after it; silence and steady noise give an empty text and language:
-   {"text":"...","language":"en","ttft_ms":0.0,"decode_tps":0.0}
-   A non-zero word_timestamps adds each word with times in seconds:
-   "words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}] */
-NEEDLE_API int needle_transcribe(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    int word_timestamps,
-    char* out,
-    int out_capacity
-);
-
-/* Live transcription: appends 16 kHz mono float PCM, about one second at a
-   time, re-transcribes the buffered audio and commits the words two consecutive
-   passes agree on; a feed longer than 30 s is taken in one-second pieces. language and keywords are as in
-   needle_transcribe. out receives the words this call committed, with times in
-   seconds from the start of the stream, and the unconfirmed tail; returns the
-   number of words committed:
-   {"text":"...","words":[{"word":"...","start":0.00,"end":0.00,"probability":0.000}],
-   "pending":"...","language":"en","received":0.00,"pass_ms":0.0} */
-NEEDLE_API int needle_stream_transcribe_process(
-    const float* pcm,
-    int samples,
-    const char* language,
-    const char* keywords,
-    char* out,
-    int out_capacity
-);
-
-/* Ends the stream: the tail becomes the committed words of out, and the next
-   needle_stream_transcribe_process starts a new stream. */
-NEEDLE_API int needle_stream_transcribe_stop(
-    char* out,
-    int out_capacity
-);
-
-/* Embeds text or speech: exactly one of input and pcm is non-null. Text returns
-   the model's embedding dimension, speech one row of that width per 80 ms frame,
-   flattened. A null output returns the float count without computing. */
-NEEDLE_API int needle_embed(
-    const char* input,
-    const float* pcm,
-    int samples,
-    float* out,
-    int out_capacity
-);
-
-#ifdef __cplusplus
-}
-#endif
-#endif

python/cactus_needle-3.0.0-py3-none-macosx_11_0_arm64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f5c05efdd195c92effd8507d1259d6e509b9c5a8823939e67f2be4e83811b44b
-size 376196

python/cactus_needle-3.0.0-py3-none-macosx_11_0_x86_64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:01c1d8874266013e32b539c7b154b811f8268a01e7ea992eea40e5e1d541c55a
-size 430782

python/cactus_needle-3.0.0-py3-none-manylinux2014_aarch64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:653f41d440f14ad53cf0c4597fc9d960cbf059ae51a38ec0fb4f54a8873d5c0c
-size 500887

python/cactus_needle-3.0.0-py3-none-manylinux2014_x86_64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:a1eae4b94675ae025ebdb380401e0d9cab1d1f6c34d4fe1251166f1ba2faf16e
-size 530108

python/cactus_needle-3.0.0-py3-none-musllinux_1_2_aarch64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:4f826703197c3654ec426b3a2651057eb07496afb669c7d46f0aacf7844478a4
-size 500458

python/cactus_needle-3.0.0-py3-none-musllinux_1_2_x86_64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:f2b132474722ac032269782c2fa7ec459758ab43624843be4e3b16bf7cf7abee
-size 530918

python/cactus_needle-3.0.0-py3-none-win_amd64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:06fde9731929f53a7033e57f037f9262f99a3cdc2758d8d7bffae91404fb8665
-size 547384

python/cactus_needle-3.0.0-py3-none-win_arm64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:5b1da56516304bbc2ba6ec819ab9e6f72aad2525f14d9327f15d2d5edc1f9423
-size 477839

python/cactus_needle-3.0.1-py3-none-macosx_11_0_arm64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:161c3aacfb6e54443925b389a69eb58a1861e60af19bbdf8f39d89992c5d7436
-size 387232

python/cactus_needle-3.0.1-py3-none-macosx_11_0_x86_64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:941883e51fb2530706f1a115a0ea0062bb37501edaad8a6f08b85e12c4f5ca76
-size 431615

python/cactus_needle-3.0.1-py3-none-manylinux2014_aarch64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:fc0c550b64627ed20101d1ac6de736bf0d15fb592d649f24bacba4e7340fc3df
-size 517746

python/cactus_needle-3.0.1-py3-none-manylinux2014_x86_64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:05770ef9a85686583968ea15f62f9ad44217e078efdaa99559d3208bb8a369b0
-size 536871

python/cactus_needle-3.0.1-py3-none-musllinux_1_2_aarch64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:ec307274ed14d8a11be448e1546d3a330704a8d76a96a2f99de12ca14ed8ee64
-size 517367

python/cactus_needle-3.0.1-py3-none-musllinux_1_2_x86_64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:1b2f5f560fcf8d2033c0ade7ea48d8f2f228cb17f53331bf844fcceb955440e0
-size 537929

python/cactus_needle-3.0.1-py3-none-win_amd64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:7d4467726814ab18d9ce32a8a5cc23d1198a2c0557c613a00bef738121903e2f
-size 553581

python/cactus_needle-3.0.1-py3-none-win_arm64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:dfa6f8c15ca979bbe7c3e0579efdd8bf7b7afc75355e063cd00e6ac7732c9896
-size 493234

python/cactus_needle-3.0.2-py3-none-macosx_11_0_arm64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:aa6e730f3b3b46f103ba2bc1b268c402d497086030cce735846bee4d3abbf3d3
-size 387420

python/cactus_needle-3.0.2-py3-none-macosx_11_0_x86_64.whl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:cdec5cd39868f51204671cff18ca82d79de2809819f83284abade16088b1b779
-size 431850