@warlock.js/ai 4.13.0 → 4.15.0

package/CHANGELOG.md

@@ -4,6 +4,28 @@ All notable changes to `@warlock.js/ai` are documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/). `@warlock.js/*` packages are released in lockstep — every package shares the same version number, so a version below may list only the changes that affected this package.
 
+## 4.15.0
+
+### Fixed
+
+- **`ctx.run(agent, payload)` now stringifies a non-string payload, as it always claimed to.** `coerceInlineInput` in `src/supervisor/execution.ts` gated on `!("signature" in executable)` to decide whether the target was an agent — but every member of `SupervisableExecutable` (`AgentContract`, `WorkflowInstance`, `SupervisorContract`) declares `signature`, so the condition was **permanently false and the coercion never ran**. A supervisor intent calling `ctx.run(someAgent, { question: "why", attempt: 2 })` handed the raw object to `agent.execute()`, where it landed as the user message `content` — `[object Object]` in the prompt, or a provider-side payload rejection, depending on the adapter. The check now discriminates on `isAnonymous`, the one member unique to `AgentContract`. A regression test covers it; the old guard fails it with `Expected: "string" / Received: "object"`. The unreferenced `isSupervisor()` duck-type helper — whose own JSDoc admitted it could not tell a supervisor from a workflow — is removed
+- **`ToolMeta` no longer forces `label` and `actionLabel` on every tool that supplies `meta`.** It was declared as `Record<"label" | "actionLabel" | (string & {}), unknown>`, which makes both keys **required**, not optional — so any tool author who set one metadata field was made to set all of them. Now an optional-key shape with an index signature
+- **`ToolConfig.action` is checked bivariantly**, via a `ToolActionResolver<T>` method-in-wrapper. The strictly contravariant parameter position rejected heterogeneous tool arrays that work correctly at runtime
+- **`new Error(msg, { cause })` compiles.** `tsconfig.json` declared no `lib`, so it inherited the `target` default of ES2020, where `ErrorOptions` does not exist. `lib` is now `["ES2022"]`; this also resolves the `Array.at` and `String.replaceAll` errors. Emit is unchanged — `target` is still ES2020. Note `src/skills/sources/url-source.ts:122` was **not** a defect: the `cause` was always passed at runtime, the compiler simply had no type for it
+- **`TeamMemberValue` accepts the callback member form** (`IntentCallback`), which has always worked at runtime and was only rejected by the type
+- **`PlanSchema` no longer erases `~standard.jsonSchema`** from its return type
+
+### Changed
+
+- **`MockModelResponse.usage` is a new `MockUsage` type rather than the emitted `Usage`.** The script is an input, not a result: `MockModel.buildResponse` honours only `input` / `output` / `cachedTokens`, so a fixture declaring `cost` or `reasoningTokens` was silently discarded while the type promised otherwise. `total` is optional and documented as derived, because the mock recomputes it as `input + output` — an existing spec deliberately asserts that a mismatched scripted `total` is overridden
+- **The mock honours `deltas`.** Fixtures already declared the field; the mock ignored it
+- `MockSDK.model()` declares its `MockModel` return type — it always returned one, so `callHistory` is now reachable without a cast. `MockUsage` is exported from the barrel
+
+### Notes
+
+- Typecheck against the package's own TypeScript 6.0.3: **89 → 24 errors, and all 24 remaining are a monorepo-only artifact** (`TS6059`, `@warlock.js/cache` resolved through a `paths` mapping outside `rootDir`). They do not affect the published package, which ships built `exports` and `.d.mts`. In-scope errors are zero
+- Suite: **173 files / 1878 tests passing**, up one from the new regression test
+
 ## 4.12.0
 
 ### Changed

package/cjs/index.cjs

@@ -11846,7 +11846,8 @@ var MockModel = class {
 	}
 	/**
 	* Record the call, optionally delay, then emit the scripted response as a
-	* sequence of stream chunks: content split word-by-word as `delta`
+	* sequence of stream chunks: the scripted `deltas` when the entry
+	* supplies them, otherwise content split word-by-word, as `delta`
 	* chunks, each scripted tool call as a `tool-call` chunk, and finally a
 	* `done` chunk with finish reason + usage. Throws eagerly if the scripted
 	* entry carries an `error`.
@@ -11859,10 +11860,10 @@ var MockModel = class {
 		const mock = this.nextResponse();
 		if (mock.delay) await new Promise((resolve) => setTimeout(resolve, mock.delay));
 		if (mock.error) throw mock.error;
-		const words = mock.content.split(" ");
-		for (const word of words) yield {
+		const chunks = mock.deltas ?? mock.content.split(" ").map((word) => word + " ");
+		for (const chunk of chunks) yield {
 			type: "delta",
-			content: word + " "
+			content: chunk
 		};
 		if (mock.toolCalls) for (const toolCall of mock.toolCalls) yield {
 			type: "tool-call",
@@ -14514,24 +14515,10 @@ var SupervisorExecution = class {
 	* through unchanged so structured inputs work.
 	*/
 	coerceInlineInput(executable, input) {
-		if (!("signature" in executable) && typeof executable.execute === "function" && !this.isSupervisor(executable) && typeof input !== "string") return safeStringify(input);
+		if ("isAnonymous" in executable && typeof input !== "string") return safeStringify(input);
 		return input;
 	}
 	/**
-	* Heuristic detection of `SupervisorContract` — the contract carries
-	* a `signature` getter same as workflows, but supervisors expose
-	* `resume()` while workflows expose `resume(runId, options)` too.
-	* Cleanest distinguisher in the public surface: supervisors carry
-	* the `asTool` method name `as` … unfortunately so do workflows.
-	* Use the `streamableType` brand if we add one in v2; for now lean
-	* on a duck-typed check that's good enough for the ctx.run path
-	* (incorrect routing for workflows would still produce a runnable
-	* call — workflow.execute accepts the same args either way).
-	*/
-	isSupervisor(executable) {
-		return typeof executable.resume === "function" && typeof executable.signature === "string" && typeof executable.stream === "function";
-	}
-	/**
 	* Invoke the underlying dispatchable unit. Agents and workflows
 	* both satisfy `ExecutableContract<string, …>` so the call shape
 	* is uniform; the `type` discriminator picks which options get
@@ -17253,25 +17240,6 @@ function assertAcyclic(nodes, byId, plannerName) {
 
 //#endregion
 //#region ../ai/src/planner/plan-schema.ts
-/**
-* Build the Standard Schema the planning agent emits — an ordered
-* `{ steps: [...], summary? }` plan whose every step references one of
-* `capabilityNames` via the `capability` field.
-*
-* Mirrors the router's hand-built schema approach
-* (`supervisor/router-factory.ts`): the JSON Schema extension carries
-* the capability names as an `enum` so capable providers enforce the
-* choice natively, while `validate()` still accepts the shape softly so
-* providers without native structured output can pass a parsed object
-* through. Validation is intentionally lenient on `capability` — an
-* unknown name is surfaced later by the planner as a typed
-* `PlannerPlanInvalidError`, with the full forensic context, rather
-* than as an opaque schema issue here.
-*
-* `maxSteps`, when provided, is emitted as the `steps` array's
-* `maxItems` so capable providers refuse to over-produce up front
-* (the planner still truncates the tail to `skipped` defensively).
-*/
 function planSchema(capabilityNames, maxSteps) {
 	const jsonSchema = {
 		type: "object",