@niscorp/signal 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # @niscorp/signal
 
+## 0.1.3
+
+### Patch Changes
+
+- 63445cb: `complete()` and `stream()` on a decision provider say their own name.
+
+  Both run through `stepStream`, and the refusal a decision provider gives a chat verb named that instead: `signal.complete('…')` failed with `stepStream() is not available on a decision provider…` and `context.verb: "stepStream"`, for a call the caller never made.
+
+  The error now names the verb that was called — `complete() is not available on a decision provider — it answers decide() and generates no text`, `context.verb: "complete"`, and the same for `stream`. `step`, `stepStream` and `embed` already named themselves.
+
+  Only those two strings change. The code is `E_VERB_NOT_SUPPORTED` as before, it is raised at the same moment (for `stream()`, when the stream is first read), and no request is sent.
+
+  **What to change:** nothing.
+
+- 8973c15: DOCS.md says what `embed()` and `meta.provider.raw` do. `embed()` does not check `supportsEmbedding`: the flag is what `describe()` reports, and the request is sent either way; a refused request is `E_PROVIDER_ERROR` with the provider's own error under `context.raw`. `meta.provider.raw` is `null` after `complete()` and `stream()`, which read the reply as a stream and keep no body (`step()` returns the body), and it is the provider's error for a call Signal recovered from a rejection. No code changed.
+
+  **What to change:** nothing.
+
+- ce21cf7: DOCS.md says what a tool's `input` schema may be. The model is sent its JSON Schema, taken from the schema's output side, and the arguments are parsed with it once. So an `input` schema validates and does not convert:
+  - One with no JSON Schema (a `.transform()`, a `z.date()`) rejects the call before any request is made, with Zod's own error rather than a `SignalError`.
+  - One whose output is another kind than its input (`z.stringbool()`) is described to the model by its output: told `boolean`, a model that sends one gets `input_invalid` back, and it is the string that is accepted.
+
+  Convert inside `execute`. DOCS.md says this under "Defining Tools", and a test holds the first. No code changed.
+
+  **What to change:** nothing.
+
+## 0.1.2
+
+### Patch Changes
+
+- fe30458: Every package exports its `package.json`, so an app can say which version of a package it runs by reading it from the package:
+
+  ```ts
+  import prism from '@niscorp/prism/package.json' with { type: 'json' };
+  prism.version; // the version that is installed, not the range that asked for it
+  ```
+
+  Until now the `exports` map hid it, and the only way to the version was a path into `node_modules`. `check:packages` installs the tarballs and reads every package's version this way.
+
+  **What to change:** nothing. An app that read a version by path can read it by name.
+
 ## 0.1.1
 
 ### Patch Changes

package/DOCS.md

@@ -254,12 +254,14 @@ type SignalMeta = {
   retries: number;                  // validation retries that occurred
   toolCalls: ToolCallRecord[];      // tools called, args, results, timing
   provider: {
-    raw: unknown;                   // raw API response for debugging (an array when the run took several calls)
+    raw: unknown;                   // null: these calls read the reply as a stream, which leaves no body to keep (an array, one entry per call, when the run took several)
     errors: ProviderError[];        // currently always empty
   };
 };
 ```
 
+`step()` returns the provider's response body as its `raw`. Where a provider rejected a call and Signal recovered the attempt from the rejection, that call's `raw` is the provider's error.
+
 ---
 
 ## Structured Output
@@ -318,6 +320,8 @@ const searchTool = defineTool({
 
 The Zod `input` schema validates the model's arguments before `execute` runs. The return value is stringified and sent back to the model. A call to an unknown tool, arguments that fail the schema, and an `execute` that throws do not fail the run: each goes back to the model as an `error: …` tool result (and is recorded in `meta.toolCalls`).
 
+The model is sent the `input` schema as JSON Schema, taken from the schema's output side, so an `input` schema validates and does not convert. One with no JSON Schema (a `.transform()`, a `z.date()`) rejects the call before any request is made, with Zod's own error (`Transforms cannot be represented in JSON Schema`) rather than a `SignalError`. One whose output is another kind than its input (`z.stringbool()`) is described to the model by its output: told `boolean`, a model that sends one gets `input_invalid` back, and it is the string (`"true"`) that is accepted. Convert inside `execute`.
+
 ### Using Tools
 
 ```typescript
@@ -420,7 +424,7 @@ const similarity = cosine(a, b);
 
 ### Provider Support
 
-Only providers with `supportsEmbedding: true` can embed. Currently: **OpenAI** (`text-embedding-3-small`, `text-embedding-3-large`). Calling `embed()` on a provider without support throws `E_PROVIDER_ERROR`.
+`embed()` does not check `supportsEmbedding`: the flag is what `describe()` reports, and the request goes to the provider's embeddings endpoint either way. Of the known providers only **OpenAI** is marked as having one (`text-embedding-3-small`, `text-embedding-3-large`). An endpoint that refuses the request surfaces as `E_PROVIDER_ERROR` (`Embedding error: …`, the provider's own error under `context.raw`). A decision provider and the two adapters that are not implemented fail before any request is made.
 
 Use a separate Signal client for embedding — embedding models are different from chat models:
 
@@ -521,7 +525,7 @@ All errors are `SignalError` instances with a `.code` and optional `.context`:
 | `E_MISSING_SDK` | Provider SDK not installed |
 | `E_VALIDATION_FAILED` | Response failed Zod validation after all retries; a `decide()` answer failed its gate; a `reasoningEffort` the model does not take |
 | `E_MAX_ITERATIONS` | The tool loop did not finish within its turn limit |
-| `E_PROVIDER_ERROR` | Provider API error (rate limit, server error, etc.); tools or `embed()` on a provider without support; an adapter that is not implemented |
+| `E_PROVIDER_ERROR` | Provider API error (rate limit, server error, a refused `embed()`, etc.); tools on a provider without `nativeTools`; an adapter that is not implemented |
 | `E_MAX_RETRIES`, `E_TOOL_NOT_FOUND`, `E_TOOL_EXECUTION`, `E_TOOL_VALIDATION` | Declared in `ErrorCode`, not currently thrown — tool failures go back to the model as tool results, and exhausted retries are `E_VALIDATION_FAILED` |
 | `E_VERB_NOT_SUPPORTED` | A chat verb was called on a decision provider |
 

package/dist/index.cjs

@@ -1502,9 +1502,9 @@ var createSignalFromConfig = (config) => {
     });
     return { ...result, outcome: routed.outcome, wire: routed.wire };
   };
-  const stepStream = (request, streamOptions) => {
+  const stepStreamAs = (verb) => (request, streamOptions) => {
     const run = async function* () {
-      const adapter = await getChatAdapter("stepStream");
+      const adapter = await getChatAdapter(verb);
       const resolved = resolveProvider(config);
       const declared = new Set((request.tools ?? []).map((tool) => tool.name));
       const merged = config.options !== void 0 || request.options !== void 0 ? { ...request, options: { ...config.options, ...request.options } } : request;
@@ -1544,6 +1544,7 @@ var createSignalFromConfig = (config) => {
     };
     return run();
   };
+  const stepStream = stepStreamAs("stepStream");
   const decideCalibrated = async (adapter, model, request, started) => {
     const response = await adapter.decide(
       { model, state: request.state, questions: request.questions },
@@ -1631,7 +1632,7 @@ var createSignalFromConfig = (config) => {
         onRetry: config.onRetry,
         onToolCall: config.onToolCall
       },
-      { stepStream, model: resolveProvider(config).model, capabilities: resolveCapabilities(config) }
+      { stepStream: stepStreamAs("complete"), model: resolveProvider(config).model, capabilities: resolveCapabilities(config) }
     ),
     stream: (input, streamOptions) => runStream(
       {
@@ -1644,7 +1645,7 @@ var createSignalFromConfig = (config) => {
         onRetry: config.onRetry,
         onToolCall: config.onToolCall
       },
-      { stepStream, model: resolveProvider(config).model, capabilities: resolveCapabilities(config) }
+      { stepStream: stepStreamAs("stream"), model: resolveProvider(config).model, capabilities: resolveCapabilities(config) }
     ),
     // ─── Low-level primitives — the execution core itself ────
     step,