@exellix/ai-tasks 8.4.0 → 8.4.1

package/README.md

@@ -4,6 +4,18 @@ Private Git/npm package for executing **tasks** using the Woreces execution stac
 
 **Breaking — `executionStrategies` (required):** Every `runTask` request must include **`executionStrategies`**: an array of FuncX MAIN wrappers or **`[]`** for plain gateway MAIN. The old **`executionStrategyKey`** field is removed. See [BREAKING-CHANGES.md](BREAKING-CHANGES.md) and [RUNTASK_REQUEST.md](RUNTASK_REQUEST.md). Supported MAIN execution is exactly: **direct** via **`executionStrategies: []`**, **planner** before MAIN, **optimizer** after MAIN, or planner + optimizer together. Default FuncX function ids (generic envelope via **`run()`**, **`@x12i/funcx` ≥ 4.2.0** recommended): **`execution/plan`**, **`execution/evaluate-result`** (overridable via each row’s `args.functionId` when the alternate implementation uses the **same** envelope). Planner/optimizer responses are normalized with **`getRunJsonResult`** from `@x12i/funcx/functions` (also re-exported from this package as **`unwrapFuncxRunValue`** → **`getRunJsonResult`**).
 
+**Breaking — 8.4+ LLM invoke contract (no legacy):** Every `runTask` requires **`modelConfig.preActionModel`**, **`modelConfig.skillModel`**, and **`modelConfig.postActionModel`**. Do **not** send `xynthesisModel`, root `modelConfig.model`, `maxTokens`, `maxTokensCap`, or graph-era tier names (`weak` / `strong`). Token budgets are owned by **Optimixer** in `@exellix/ai-skills` (MAIN) and `@exellix/xynthesis` (PRE/POST). Send **`outputExpectation`** (xynthesis) and optional **`reasoningEffort`**, **`temperature`**, **`topP`**. See [How completion budgets work](#how-completion-budgets-work-84) and [Model profile aliases](#model-profile-aliases-x12iai-profiles).
+
+### Stack alignment (8.4+)
+
+| Package | Role in `runTask` | Minimum |
+|---------|-------------------|---------|
+| `@x12i/ai-profiles` | Profile/shortcut → wire model (`catalogLane` required on resolve) | **2.1.0** |
+| `@exellix/xynthesis` | PRE synthesis, POST audit/polish, scoping, utilities (`executeXynthesisAction`) | **4.3.0** |
+| `@exellix/ai-skills` | MAIN `runSkill` (Optimixer caps, `ModelConfig.reasoningEffort`) | **6.0.0** |
+
+Use explicit **ai-profiles** profile keys (`cheap`, `pro`, `cyber`, …) or **shortcuts** (`cheapest`, `default`, …) or **`profile/choice`** keys — not removed sync helpers or legacy tier aliases.
+
 **FuncX catalog / hosting:** Those function ids must exist in your FuncX content resolver for live **`run()`** calls — see [`documenations/funcx-catalog-hosting-checklist.md`](documenations/funcx-catalog-hosting-checklist.md).
 
 **Execution pipeline (optional):** You can use `executionPipeline` (array of pre/main/post steps) instead of a single `executionType`. PRE steps include `synthesized-context`; POST steps include `audit` (quality-gate loop) and `polish` (refinement checklist). See [BREAKING-CHANGES.md](BREAKING-CHANGES.md) for migration. When `executionPipeline` is omitted, existing `executionType` behavior is unchanged.
@@ -313,11 +325,11 @@ const res = await tasks.runTask({
   // optional
   variables: { orgName: "Acme" },
   modelConfig: {
-    preActionModel: "balanced",
-    postActionModel: "balanced",
+    preActionModel: "cheap",
+    postActionModel: "cheap",
     skillModel: "openai/gpt-5",
     temperature: 0.7,
-    maxTokens: 2000
+    topP: 0.9,
   },
   jobId: "job-1",
   agentId: "agent-1",
@@ -447,7 +459,7 @@ const expected = await analyzeExpectedRunTaskInput({
 });
 ```
 
-Each issue has **`code`**, **`severity`** (`error` \| `warning`), **`message`**, and optional **`path`** (e.g. `smartInput.paths[0].path`, `llmCall.maxTokensCap`). See [`.docs/flow-io/`](.docs/flow-io/flow-README.md) for flow-level wiring.
+Each issue has **`code`**, **`severity`** (`error` \| `warning`), **`message`**, and optional **`path`** (e.g. `smartInput.paths[0].path`, `modelConfig.preActionModel`). See [`.docs/flow-io/`](.docs/flow-io/flow-README.md) for flow-level wiring.
 
 ### Skill request analysis (`@exellix/ai-skills` 5.6+)
 
@@ -1053,28 +1065,20 @@ Use **`RunTaskResponseWithSteps<TParsed>`** when you expect steps; it extends `R
 
 ---
 
-## How max tokens are resolved (automation + caller controls)
+## How completion budgets work (8.4+)
 
-`@exellix/xynthesis` 3.1+ ships `resolveMaxTokens` — a deterministic function that picks the right `maxTokens` for any LLM call from `(inputText, outputExpectation, modelId, callerMaxTokens?, structuredOutput?)`. `@exellix/ai-tasks` invokes it on **every** xynthesis-backed call (PRE synthesis, AI scoping, POST audit, POST polish, structured-repair fallback) so callers don't have to pick a number.
+Orchestrators send **model** + **sampling** + **`reasoningEffort`** + (for xynthesis) **`outputExpectation`**. They do **not** send completion token counts.
 
-**The pipeline is:**
+| Phase | Package | Caller sends | Package owns |
+|-------|---------|--------------|--------------|
+| **MAIN** | `@exellix/ai-skills` ≥6 | `modelConfig` → `{ model, temperature, topP, reasoningEffort, … }` | Optimixer + Catalox skill catalog (`maxTokens` on `ModelConfig` is rejected) |
+| **PRE / POST / scoping / utility** | `@exellix/xynthesis` ≥4.3 | `outputExpectation` (required on every hop), optional `reasoningEffort`, `temperature`, `topP` | `resolveEffectiveMaxTokens` inside `executeXynthesisAction` |
 
-1. **Estimate input tokens** from `inputText` (system + user + extra material) using `xynthesis.estimateTokens`.
-2. **Resolve the effective `OutputExpectation`** = caller's `llmCall.outputExpectation` → per-action default (`xynthesis.resolveOutputExpectation('synthesis' | 'audit' | 'fix' | 'pick-best' | 'craft-final')`) → stage-local default (e.g. AI scoping uses `{ size: { mode: "absolute", minWords: 5, maxWords: 200 }, density: "concise" }`) → xynthesis package fallback.
-3. **Compute estimated output tokens** from the expectation (absolute words → tokens; relative → ratio × input tokens), multiplied by `headroomMultiplier(density)` and (if `structuredOutput`) the structured-output factor.
-4. **Cap at the model's `maxOutputTokens`** from `getModelCapabilities(modelId)` (unknown models fall back to `{ contextWindow: 128_000, maxOutputTokens: 4_096, completionTokenCost: "medium" }`).
-5. **Honor the caller's `maxTokensCap`** as a HARD CEILING — the auto-sizer can pick a smaller number, but never larger.
-6. The `resolveMaxTokens` result (`{ maxTokens, reason: "computed" | "caller-override" | "model-ceiling" | "fallback", diagnostics: { … } }`) is forwarded to xynthesis as `tokenResolutionMetadata` and surfaced in trace mode as `LlmCallObservation.request.tokenResolution`.
+**Xynthesis `outputExpectation`** is sizing/density **intent** for Optimixer — not a literal token count. ai-tasks resolves a per-stage default when the caller omits it (`resolveOutputExpectation` / `resolveLlmOutputExpectationForXynthesis`).
 
-**To adjust per-call dynamically** (without losing the automation):
+**Rejected on the wire (validation):** `modelConfig.maxTokens`, `llmCall.maxTokens`, `llmCall.maxTokensCap`, deprecated `xynthesisModel`, root `modelConfig.model`.
 
-- Set `llmCall.outputExpectation` to bias the auto-sizer toward smaller / larger / denser output.
-- Set `llmCall.maxTokensCap` to bound the upper limit (e.g. for cost ceilings).
-- Leave both unset to get the per-stage / per-action default.
-
-**MAIN skill (`runSkill`):** completion token budget is set **only** by `@exellix/ai-skills` (Optimixer + Catalox catalog). Do **not** put `maxTokens` on `modelConfig` — ai-skills ≥5.9 rejects caller `modelConfig.maxTokens`. `RunTaskRequest.llmCall.maxTokensCap` does **not** override MAIN today; it applies to xynthesis-backed stages (PRE synthesis, POST audit/polish, scoping, utilities) via `resolveMaxTokens`.
-
-**Xynthesis-backed stages:** use `llmCall.outputExpectation` and optional `llmCall.maxTokensCap` (hard ceiling on the auto-sizer). See [`documenations/upstream-feature-requests/ai-skills-llm-observability.md`](documenations/upstream-feature-requests/ai-skills-llm-observability.md) for parity requests (e.g. `outputExpectation` on `RunSkillRequest`).
+**Trace:** use `usage.maxTokensRequested` / `invokeSummary` diagnostics after invoke — not pre-set caps on the request.
 
 ---
 
@@ -1084,14 +1088,16 @@ Use **`RunTaskResponseWithSteps<TParsed>`** when you expect steps; it extends `R
 
 | Path | Slot / field | Resolved before |
 |------|----------------|-----------------|
-| **Xynthesis** (PRE synthesis, POST audit/polish, AI scoping, utilities) | `preActionModel`, `postActionModel`, `SynthesisConfig.llmCall.model`, `AuditConfig.llmCall.*`, `PolishConfig.llmCall`, `RunUtilityRequest.exec.model`, env fallbacks (`SYNTHESIS_MODEL`, `AUDIT_MODEL`, …) | `executeXynthesisAction` / `runPostStepLlmCall` |
+| **Xynthesis** (PRE synthesis, POST audit/polish, AI scoping, utilities) | `preActionModel`, `postActionModel`, step `llmCall.model`, `RunUtilityRequest.exec.model` | `executeXynthesisAction` / `runPostStepLlmCall` |
 | **ai-skills MAIN** | `skillModel`, `RunTaskRequest.llmCall.model` | `runSkill` (via `DirectExecutionStrategy`) |
 
-**Accepted alias shapes:**
+**Accepted alias shapes** (`@x12i/ai-profiles` v2.1+):
+
+- **Profile keys:** `cheap`, `fast`, `balanced`, `deep`, `pro`, `json`, `agentic`, `research`, `cyber`, …
+- **Shortcuts:** `cheapest`, `default`, `best`, `standard`, `thinking`, `schema`, …
+- **Explicit choice:** `cheap/default`, `pro@default`, …
 
-- **ai-profiles profiles:** `cheap`, `fast`, `balanced`, `deep`, `pro`, `json`, `agentic`, `research`
-- **ai-profiles shortcuts:** `cheapest`, `default`, `best`, `standard`, `thinking`, `schema`, `agent`, `web-research`, … (see `@x12i/ai-profiles` README)
-- **Legacy graph tiers:** `weak` → `cheap`, `strong` → `pro`, `default` → `balanced`
+**Not accepted:** legacy graph tiers (`weak`, `strong`), deprecated `xynthesisModel`, or sync-only alias guessing removed in ai-profiles 2.1. Unknown keys fail at **`resolveAIProfile`** with a clear error.
 
 **Example (aliases on the request — resolved inside `runTask`):**
 
@@ -1118,7 +1124,7 @@ Concrete ids (`openrouter/...`, `anthropic/claude-sonnet-4`, `openai/gpt-5`, …
 - **No change** if you already send concrete provider model ids.
 - **New:** you may send ai-profiles aliases on `modelConfig`, `llmCall.model`, and pipeline step configs — graph-engine no longer has to pre-resolve every alias before `runTask` (hosts that already resolve can keep doing so; double resolution is a no-op for concrete ids).
 - **Validation:** alias tokens on `modelConfig` slots are accepted; unknown aliases fail at resolution with a clear error.
-- **Optional helpers** (for hosts/tests): `resolveModelReference`, `resolveRunTaskModelReferences`, `isResolvableModelAlias`.
+- **Helpers:** `resolveModelReference`, `resolveRunTaskModelReferences`, `isResolvableModelAlias` (true only for **`profile/choice`** keys and **shortcuts** — bare profile keys are resolved at invoke, not sync-listed).
 
 Resolution uses the ai-profiles registry (`auto`: remote refresh with bundled fallback). See [`.docs/ai-tasks-model-profile-aliases-7x.md`](.docs/ai-tasks-model-profile-aliases-7x.md).
 
@@ -1130,14 +1136,13 @@ Resolution uses the ai-profiles registry (`auto`: remote refresh with bundled fa
 
 ```typescript
 type LlmCallConfig = {
-  model?: string;             // provider/model id or @x12i/ai-profiles alias (resolved at call time)
-  maxTokensCap?: number;      // HARD CEILING for resolveMaxTokens (does NOT disable automation)
-  maxTokens?: number;         // alias for maxTokensCap (backward compat)
+  model?: string;                        // provider/model id or ai-profiles alias (resolved at call time)
   temperature?: number;
   topP?: number;
-  maxOutputLength?: number;   // post-call character truncation
+  reasoningEffort?: OptimixerReasoningEffort; // overrides Catalox default when set
+  maxOutputLength?: number;              // post-call character truncation
   timeoutMs?: number;
-  outputExpectation?: OutputExpectation; // drives resolveMaxTokens auto-sizing
+  outputExpectation?: OutputExpectation; // xynthesis Optimixer intent (not a token count)
 };
 ```
 
@@ -1152,7 +1157,7 @@ type LlmCallConfig = {
 | POST audit (evaluator) | `AuditConfig.llmCall` or `AuditConfig.audit.llmCall` |
 | POST audit (synthesis-merge) | `AuditConfig.audit.synthesis.llmCall` |
 | POST polish | `PolishConfig.llmCall` |
-| Utility (xynthesis-finalize) | `RunUtilityRequest.exec.{model, maxTokensCap, temperature, topP, outputExpectation, ...}` |
+| Utility (xynthesis-finalize) | `RunUtilityRequest.exec.{model, temperature, topP, reasoningEffort, outputExpectation, ...}` |
 
 **Builder helpers (`TaskRequestBuilder`):**
 
@@ -1170,7 +1175,6 @@ type LlmCallConfig = {
 |---------------------|--------|
 | `AUDIT_MODEL`, `POLISH_MODEL`, `SYNTHESIS_MODEL`, `AI_SCOPING_MODEL` | Model override for that stage |
 | `AUDIT_TIMEOUT_MS`, `POLISH_TIMEOUT_MS`, `SYNTHESIS_TIMEOUT_MS`, `AI_SCOPING_TIMEOUT_MS` | Per-call timeout override |
-| `AUDIT_MAX_TOKENS_CAP`, `POLISH_MAX_TOKENS_CAP`, `SYNTHESIS_MAX_TOKENS_CAP` | Hard ceiling override |
 | `AUDIT_TEMPERATURE`, `POLISH_TEMPERATURE`, `SYNTHESIS_TEMPERATURE` | Temperature override |
 | `AUDIT_TOP_P`, `POLISH_TOP_P`, `SYNTHESIS_TOP_P` | Top-P override |
 | `AUDIT_MAX_OUTPUT_LENGTH`, `POLISH_MAX_OUTPUT_LENGTH`, `SYNTHESIS_MAX_OUTPUT_LENGTH` | Post-call char truncation override |
@@ -1209,7 +1213,7 @@ When `RunTaskRequest.executionMode === "trace"` (or `RunUtilityRequest.exec.exec
 type LlmCallObservation =
   | {
       source: "xynthesis"; stage: LlmCallStage; stepId?: string;
-      request: LlmCallRequestSnapshot; // includes resolved tokenResolution from resolveMaxTokens
+      request: LlmCallRequestSnapshot;
       summary?: InvokeAttemptSummary;  // from executeXynthesisAction on success / typed errors on failure
       debugTrace?: XynthesisDebugTrace; // present when executionMode: "trace" was forwarded
       durationMs: number; ok: boolean; error?: { name: string; message: string };
@@ -1249,7 +1253,6 @@ import {
   type LlmCallConfig,
   type InvokeAttemptSummary,
   type RunSkillDiagnostics,
-  resolveMaxTokens,
   resolveOutputExpectation,
   ACTION_OUTPUT_DEFAULTS,
   getModelCapabilities,
@@ -1263,17 +1266,26 @@ import { runTask, type LlmCallConfig } from "@exellix/ai-tasks";
 
 const llmCall: LlmCallConfig = {
   model: "gpt-5-mini",
-  maxTokensCap: 4096,                                   // hard ceiling
   outputExpectation: { size: { kind: "absolute", maxWords: 600 }, density: "default" },
   temperature: 0.4,
+  reasoningEffort: "medium",
 };
 
 const result = await runTask({
   skillKey: "tasks/security-risk-summary",
+  agentId: "agent-1",
+  jobTypeId: "security-job",
+  taskTypeId: "security-task",
+  executionStrategies: [],
+  modelConfig: {
+    preActionModel: "cheap",
+    postActionModel: "cheap",
+    skillModel: "balanced",
+  },
   input: { assetId: "a-123" },
   executionMode: "trace",
   llmCall,
-  aiScopingOptions: { llmCall: { model: "gpt-5-nano", maxTokensCap: 512 } },
+  aiScopingOptions: { llmCall: { model: "cheap", outputExpectation: { size: { kind: "absolute", maxWords: 200 }, density: "concise" } } },
   // executionPipeline: [{ phase: "pre", type: "synthesized-context", config: { llmCall } }, { phase: "main", type: "direct" }],
 });
 
@@ -1864,7 +1876,7 @@ Builder class for constructing task requests with a fluent API.
 - `withGraphId(graphId: string): this` - Set graph identifier
 - `withNodeId(nodeId: string): this` - Set node identifier
 - `withPrevNodeId(prevNodeId: string): this` - Set previous node identifier
-- `withModelConfig(modelConfig: ModelConfig): this` - Set model configuration (model, temperature, maxTokens, etc.)
+- `withModelConfig(modelConfig: RunTaskModelConfig): this` - Set the required 3-slot model triplet + tuning
 - `withTemplateRenderOptions(templateRenderOptions: TemplateRenderOptions): this` - Per-task gateway / parser template overrides (v4)
 - `withTemplateTokens(templateTokens: GatewayTemplateTokens): this` - Per-task `templateTokens` overlay
 - `withTimeout(timeoutMs: number): this` - Set timeout
@@ -1886,9 +1898,10 @@ const request = new TaskRequestBuilder()
   .withAiSkillsCorrelation("my-agent", "my-job-type", "my-task-type")
   .withExecutionStrategies([]) // [] = plain MAIN; omit only if you rely on build() defaulting strategies to []
   .withModelConfig({
-    model: "gpt-5",
+    preActionModel: "cheap",
+    postActionModel: "cheap",
+    skillModel: "gpt-5",
     temperature: 0.7,
-    maxTokens: 2000
   })
   .withJobMemory(jobMemory)
   .withTaskMemory(taskMemory)
@@ -1947,7 +1960,7 @@ interface RunTaskRequest {
   jobMemory?: JobHistory;               // History of previous task results
   taskMemory?: TaskHistory;              // History of skills executed
   executionMemory?: ExecutionHistory;    // History of execution context (execution-level memory)
-  modelConfig?: ModelConfig;            // Model configuration (model, temperature, maxTokens, etc.)
+  modelConfig: RunTaskModelConfig;      // Required 3-slot triplet + optional tuning
   jobId?: string;
 
   // Graph execution context (optional)
@@ -2106,36 +2119,34 @@ Exported type for **`RunTaskRequest.narrix`**. Includes **`datasetId`**, optiona
 import type { NarrixPreProcessorConfig } from "@exellix/ai-tasks";
 ```
 
-### `ModelConfig`
+### `RunTaskModelConfig`
 
-Model configuration for per-request model selection and generation parameters:
+Required on every `runTask()` — three slots plus optional tuning (no `maxTokens`, no legacy `model` / `xynthesisModel`):
 
 ```typescript
-import type { ModelConfig } from "@exellix/ai-tasks";
-
-interface ModelConfig {
-  model?: string;              // Model identifier (e.g., "gpt-5")
-  modelId?: string;            // Provider-specific model ID
-  provider?: string;           // Provider name (e.g., "openai", "anthropic")
-  temperature?: number;        // 0.0 to 2.0 - Controls randomness
-  maxTokens?: number;          // Maximum tokens to generate
-  topP?: number;               // 0.0 to 1.0 - Nucleus sampling
-  frequencyPenalty?: number;   // -2.0 to 2.0
-  presencePenalty?: number;    // -2.0 to 2.0
-  stop?: string[];            // Stop sequences
-  [key: string]: any;         // Additional provider-specific parameters
+import type { RunTaskModelConfig } from "@exellix/ai-tasks";
+
+interface RunTaskModelConfig {
+  preActionModel: string;   // ai-profiles alias (xynthesis PRE)
+  skillModel: string;       // alias or concrete id (ai-skills MAIN)
+  postActionModel: string;  // ai-profiles alias (xynthesis POST)
+  temperature?: number;
+  topP?: number;
+  reasoningEffort?: OptimixerReasoningEffort;
+  frequencyPenalty?: number;
+  presencePenalty?: number;
 }
 ```
 
-**Example (concrete ids or aliases):**
+**Example:**
 ```typescript
-const modelConfig = {
+const modelConfig: RunTaskModelConfig = {
   preActionModel: "cheap",
   postActionModel: "cheap",
-  skillModel: "balanced",
+  skillModel: "cyber",
   temperature: 0.7,
-  maxTokens: 2000,
-  topP: 0.9
+  topP: 0.9,
+  reasoningEffort: "medium",
 };
 
 const result = await runTask({
@@ -2334,11 +2345,12 @@ const result = await tasks.runTask({
   executionType: ExecutionType.DIRECT,
   input: { data: "analyze this" },
   modelConfig: {
-    model: "gpt-5",
+    preActionModel: "cheap",
+    postActionModel: "cheap",
+    skillModel: "gpt-5",
     temperature: 0.7,
-    maxTokens: 2000,
-    topP: 0.9
-  }
+    topP: 0.9,
+  },
 });
 
 // Or using the builder
@@ -2350,9 +2362,10 @@ const request = new TaskRequestBuilder()
   .withAiSkillsCorrelation("agent-1", "analysis-job", "analysis-task")
   .withExecutionStrategies([])
   .withModelConfig({
-    model: "gpt-5",
+    preActionModel: "cheap",
+    postActionModel: "cheap",
+    skillModel: "gpt-5",
     temperature: 0.5,
-    maxTokens: 4000
   })
   .build();
 

package/dist/core/task-sdk.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"task-sdk.d.ts","sourceRoot":"","sources":["../../src/core/task-sdk.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAazD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAuB,MAAM,mBAAmB,CAAC;AA2BzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AA2OxD,KAAK,iBAAiB,GAAG,mBAAmB,CAAC;AA0S7C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,+FAA+F;IAC/F,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,CAAC;AAEF,qBAAa,gBAAgB;IAIzB,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,iBAAiB;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;gBAGjC,YAAY,EAAE,iBAAiB,EACjC,QAAQ,EAAE;QACzB,OAAO,CAAC,OAAO,GAAG,GAAG,EACnB,KAAK,EAAE,GAAG,EACV,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GACzC,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;KACtC,EACD,OAAO,CAAC,EAAE,uBAAuB;IAQ7B,OAAO,CAAC,OAAO,GAAG,GAAG,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IA6kDtF;;OAEG;YACW,6BAA6B;IAqhB3C;;;;;OAKG;YACW,cAAc;CAyR7B"}
+{"version":3,"file":"task-sdk.d.ts","sourceRoot":"","sources":["../../src/core/task-sdk.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AAazD,OAAO,EAAE,cAAc,EAAE,eAAe,EAAuB,MAAM,mBAAmB,CAAC;AA2BzF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AA2OxD,KAAK,iBAAiB,GAAG,mBAAmB,CAAC;AA0S7C;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,+FAA+F;IAC/F,OAAO,CAAC,EAAE,mBAAmB,CAAC;CAC/B,CAAC;AAEF,qBAAa,gBAAgB;IAIzB,SAAS,CAAC,QAAQ,CAAC,YAAY,EAAE,iBAAiB;IAClD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAJ3B,SAAS,CAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,mBAAmB,CAAC;gBAGjC,YAAY,EAAE,iBAAiB,EACjC,QAAQ,EAAE;QACzB,OAAO,CAAC,OAAO,GAAG,GAAG,EACnB,KAAK,EAAE,GAAG,EACV,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,GACzC,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;KACtC,EACD,OAAO,CAAC,EAAE,uBAAuB;IAQ7B,OAAO,CAAC,OAAO,GAAG,GAAG,EAAE,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC;IA6kDtF;;OAEG;YACW,6BAA6B;IAshB3C;;;;;OAKG;YACW,cAAc;CAyR7B"}

package/dist/core/task-sdk.js

@@ -2152,6 +2152,7 @@ export class WorexClientTasks {
                         // Caller-supplied outputExpectation overrides the per-action default in the structured-repair path.
                         outputExpectation: synthLlmCall.outputExpectation,
                         reasoningEffort: synthLlmCall.reasoningEffort,
+                        topP: synthLlmCall.topP,
                         // Forward trace mode so the structured gateway returns a `debugTrace` (lifted into observations elsewhere).
                         executionMode: traceCollector ? "trace" : undefined,
                         jobId: request.jobId,