@wildo-ai/saas-models 1.0.1 → 1.1.0

package/dist/esm/flows-actors/actors.shared.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"actors.shared.schemas.d.ts","sourceRoot":"","sources":["../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EAAuE,oBAAoB,EAA0B,MAAM,sCAAsC,CAAC;AAezK,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,iBAAiB,sBAAsB;IACvC,cAAc,oBAAoB;CACnC;AAGD,oBAAY,mBAAmB;IAC7B,OAAO,YAAY;IACnB,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;CACxC;AAED,eAAO,MAAM,WAAW;;;;;;;uCAOtB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAMhD,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAG5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO5D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uCAwBtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}
+{"version":3,"file":"actors.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAC3E,OAAO,EAAmG,oBAAoB,EAAG,MAAM,sCAAsC,CAAC;AAe9K,oBAAY,mBAAmB;IAC7B,WAAW,gBAAgB;IAC3B,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,QAAQ,aAAa;IACrB,iBAAiB,sBAAsB;IACvC,cAAc,mBAAmB;CAClC;AAGD,oBAAY,mBAAmB;IAC7B,OAAO,YAAY;IACnB,cAAc,mBAAmB;IACjC,iBAAiB,sBAAsB;CACxC;AAED,eAAO,MAAM,WAAW;;;;;;;iBAOtB,CAAC;AACH,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAMhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAS5B,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO5D,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8BtC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,2BAA2B,CAAC,CAAC"}

package/dist/esm/flows-actors/actors.shared.schemas.js

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { WildoError_BackendSchema } from "../errors/errors.shared.schemas.js";
 import { FlowsActors_Status } from "./flows-actors.commons.shared.schemas.js";
-import { FlowActorSystem_ErrorStates_Schema, FlowActorSystem_ExecutionSchema, FlowActorSystem_Kind, FlowActorSystemSchema, } from "./flows-actors.system.shared.schemas.js";
+import { FlowActorSystem_BaseSchema, FlowActorSystem_ErrorStates_Schema, FlowActorSystem_ExecutionSchema, FlowActorSystem_Kind, } from "./flows-actors.system.shared.schemas.js";
 import { Actors_Task_Schema, Actors_Walkthrough_Schema, ActorsSystem_ExecutionPlan_Schema } from "./tasks.actors.shared.schemas.js";
 //===============================================================
 //  Actor
@@ -20,7 +20,7 @@ export var Actor_Role_Category;
     Actor_Role_Category["ANALYZER"] = "analyzer";
     Actor_Role_Category["REVIEWER"] = "reviewer";
     Actor_Role_Category["HUMAN_IN_THE_LOOP"] = "human_in_the_loop";
-    Actor_Role_Category["FLOW_EXECUTION"] = "flow_exectution";
+    Actor_Role_Category["FLOW_EXECUTION"] = "flow_execution";
 })(Actor_Role_Category || (Actor_Role_Category = {}));
 export var Actor_ExecutionMode;
 (function (Actor_ExecutionMode) {
@@ -39,8 +39,25 @@ export const ActorSchema = z.object({
 //===============================================================
 //  Actor System
 //===============================================================
-export const ActorSystemSchema = FlowActorSystemSchema.extend({
-    type: z.literal(FlowActorSystem_Kind.ACTOR),
+/**
+ * The ACTOR specialization of the system base — the schema that OWNS a system's
+ * actor list. `actors` is declared here and in no other system schema: the base
+ * cannot declare it, because a FLOW system has no actors. (Unrelated `actors`
+ * members exist on the TASK schemas; those point at one actor, they are not a
+ * system's roster.)
+ *
+ * An actor system must therefore be parsed with this schema, or one derived
+ * from it. Parsing one with `FlowActorSystem_BaseSchema` strips `actors`
+ * silently — see the warning there.
+ */
+export const ActorSystemSchema = FlowActorSystem_BaseSchema.extend({
+    /**
+     * Narrows the inherited `kind` discriminant to ACTOR. The historical shape
+     * added a separate `type` field here while every consumer (backend registry,
+     * execution schemas, flows counterpart) discriminates on `kind` — fixed
+     * 2026-07-02 (meta-workflows Step 0 hygiene; no `.type` consumer existed).
+     */
+    kind: z.literal(FlowActorSystem_Kind.ACTOR),
     actors: z.array(z.lazy(() => ActorSchema)),
 });
 //===============================================================
@@ -60,12 +77,18 @@ export const ActorSystem_ExecutionSchema = FlowActorSystem_ExecutionSchema.exten
             timestamp: z.iso.datetime(),
         })),
     }).array(),
+    /**
+     * Overrides the base `errorItems` with the actor-execution-scoped variant
+     * (adds taskId/planStepId locators). Historically this extension used a
+     * divergent `errors` key coexisting with the base `errorItems` — aligned
+     * 2026-07-02 (meta-workflows Step 0 hygiene; the field had no consumers).
+     */
     errorStates: FlowActorSystem_ErrorStates_Schema.extend({
-        errors: WildoError_BackendSchema.extend({
+        errorItems: WildoError_BackendSchema.extend({
             systemRef: z.string(),
             taskId: z.string().optional(),
             planStepId: z.string().optional(),
         }).array().optional(),
     }).optional(),
 });
-//# sourceMappingURL=actors.shared.schemas.js.map
+//# sourceMappingURL=actors.shared.schemas.js.map

package/dist/esm/flows-actors/actors.shared.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"actors.shared.schemas.js","sourceRoot":"","sources":["../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"actors.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/actors.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from \"zod\";\n\nimport { WildoError_BackendSchema } from \"../errors/errors.shared.schemas\";\nimport { FlowsActors_Status } from \"./flows-actors.commons.shared.schemas\";\nimport { FlowActorSystem_BaseSchema, FlowActorSystem_ErrorStates_Schema, FlowActorSystem_ExecutionSchema, FlowActorSystem_Kind, } from \"./flows-actors.system.shared.schemas\";\nimport { Actors_Task_Schema, Actors_Walkthrough_Schema, ActorsSystem_ExecutionPlan_Schema } from \"./tasks.actors.shared.schemas\";\n\n\n//===============================================================\n//  Actor\n// --------\n// Actors are reactive components that subscribe to event topics\n// and respond with automated processing. They enable event-driven\n// architecture by processing messages asynchronously, supporting\n// batch processing, filtering, and various error handling strategies.\n// Actors can emit new events, creating event chains and workflows.\n//===============================================================\n\n\nexport enum Actor_Role_Category {\n  COORDINATOR = \"coordinator\",\n  TASK_PLANNER = \"task_planner\",\n  OPERATOR = \"operator\",\n  ANALYZER = \"analyzer\",\n  REVIEWER = \"reviewer\",\n  HUMAN_IN_THE_LOOP = \"human_in_the_loop\",\n  FLOW_EXECUTION = \"flow_execution\"\n}\n\n\nexport enum Actor_ExecutionMode {\n  AGENTIC = \"agentic\",\n  FLOW_EXECUTION = \"flow_execution\",\n  HUMAN_INTERACTION = \"human_interaction\",\n}\n\nexport const ActorSchema = z.object({\n  ref: z.string().min(1),\n  displayName: z.string().min(1),\n  roleCategory: z.enum(Actor_Role_Category),\n  executionMode: z.enum(Actor_ExecutionMode),\n  agentRef: z.string().optional(),\n  flowRef: z.string().optional(),\n});\nexport type Actor = z.infer<typeof ActorSchema>;\n\n//===============================================================\n//  Actor System\n//===============================================================\n\n/**\n * The ACTOR specialization of the system base — the schema that OWNS a system's\n * actor list. `actors` is declared here and in no other system schema: the base\n * cannot declare it, because a FLOW system has no actors. (Unrelated `actors`\n * members exist on the TASK schemas; those point at one actor, they are not a\n * system's roster.)\n *\n * An actor system must therefore be parsed with this schema, or one derived\n * from it. Parsing one with `FlowActorSystem_BaseSchema` strips `actors`\n * silently — see the warning there.\n */\nexport const ActorSystemSchema = FlowActorSystem_BaseSchema.extend({\n  /**\n   * Narrows the inherited `kind` discriminant to ACTOR. The historical shape\n   * added a separate `type` field here while every consumer (backend registry,\n   * execution schemas, flows counterpart) discriminates on `kind` — fixed\n   * 2026-07-02 (meta-workflows Step 0 hygiene; no `.type` consumer existed).\n   */\n  kind: z.literal(FlowActorSystem_Kind.ACTOR),\n  actors: z.array(z.lazy(() => ActorSchema)),\n});\nexport type ActorSystem = z.infer<typeof ActorSystemSchema>;\n\n\n//===============================================================\n//  Actor System Execution\n//===============================================================\n\nexport const ActorSystem_ExecutionSchema = FlowActorSystem_ExecutionSchema.extend({\n  kind: z.literal(FlowActorSystem_Kind.ACTOR),\n\n  plan: ActorsSystem_ExecutionPlan_Schema.optional(),\n  walkthrough: Actors_Walkthrough_Schema.optional(),\n  standaloneTasks: z.array(Actors_Task_Schema),\n\n  standaloneTaskStates: z.object({\n    taskId: z.string(),\n    status: z.enum(FlowsActors_Status),\n    updatedAt: z.iso.datetime(),\n    statusChanges: z.array(z.object({\n      status: z.enum(FlowsActors_Status),\n      timestamp: z.iso.datetime(),\n    })),\n  }).array(),\n\n  /**\n   * Overrides the base `errorItems` with the actor-execution-scoped variant\n   * (adds taskId/planStepId locators). Historically this extension used a\n   * divergent `errors` key coexisting with the base `errorItems` — aligned\n   * 2026-07-02 (meta-workflows Step 0 hygiene; the field had no consumers).\n   */\n  errorStates : FlowActorSystem_ErrorStates_Schema.extend({\n    errorItems: WildoError_BackendSchema.extend({\n      systemRef: z.string(),\n      taskId: z.string().optional(),\n      planStepId: z.string().optional(),\n    }).array().optional(),\n  }).optional(),\n});\nexport type ActorSystem_Execution = z.infer<typeof ActorSystem_ExecutionSchema>;\n"]}

package/dist/esm/flows-actors/agent-traceability.shared.schemas.d.ts

@@ -0,0 +1,237 @@
+import { z } from 'zod';
+/**
+ * Verbosity policy for engine-level agent-call traceability. Promotes the
+ * companion's previously-local `WILDO_DEV_COMPANION_TRACEABILITY_LEVEL` to a
+ * shared engine contract so every agent caller (companion, backend runtime,
+ * minions, workers) and every sink (filesystem, logger, OTel) speak the same
+ * levels.
+ *
+ * - `NONE`          — tracing fully off; emitters must no-op before any I/O.
+ * - `DEBUG`         — per-call metadata + token usage + latency (no payloads).
+ * - `DEBUG_VERBOSE` — adds the resolved prompt input + raw output payloads.
+ */
+export declare enum AgentTraceabilityLevel {
+    NONE = "NONE",
+    DEBUG = "DEBUG",
+    DEBUG_VERBOSE = "DEBUG_VERBOSE"
+}
+/** Numeric ordering for `AgentTraceabilityLevel` gating comparisons. */
+export declare const AGENT_TRACEABILITY_LEVEL_ORDER: Record<AgentTraceabilityLevel, number>;
+/**
+ * True when `activeLevel` is at least `minimumLevel` — the canonical gate every
+ * sink/emitter uses so a record is persisted only when the active policy meets
+ * the record's minimum verbosity.
+ */
+export declare function agentTraceabilityLevelAllows(activeLevel: AgentTraceabilityLevel, minimumLevel: AgentTraceabilityLevel): boolean;
+/**
+ * The more verbose of two levels — for hosts that COMPOSE traceability
+ * concerns behind one policy binding. A host policy must never be LESS
+ * verbose than any interested sink: a companion whose filesystem tracing is
+ * off (`NONE`) but whose LLM-observability provider is active still needs
+ * `DEBUG` so the emission reaches the sinks (each sink then self-gates).
+ * Replacing a live policy with a static lower level silently kills every
+ * downstream sink — the failure mode that motivated this helper.
+ */
+export declare function maxAgentTraceabilityLevel(a: AgentTraceabilityLevel, b: AgentTraceabilityLevel): AgentTraceabilityLevel;
+/** Engine-resolved traceability policy handed to `AgentsBackendService`. */
+export declare const AgentTraceabilityPolicySchema: z.ZodObject<{
+    level: z.ZodDefault<z.ZodEnum<typeof AgentTraceabilityLevel>>;
+}, z.core.$strip>;
+export type AgentTraceabilityPolicy = z.infer<typeof AgentTraceabilityPolicySchema>;
+/** Terminal outcome of a single agent invocation. */
+export declare enum AgentCallOutcome {
+    SUCCESS = "success",
+    FAILURE = "failure"
+}
+/**
+ * WHAT KIND of model call a trace records — the operation-aware axis observability sinks branch
+ * on (RAG plan DL2/H4). The two kinds differ structurally, not cosmetically:
+ *
+ * - a GENERATION consumes prompt tokens and produces completion tokens; its usage is complete
+ *   only when BOTH dimensions are present, and its payload (prompt/completion text) may be
+ *   forwarded to analytics under an explicit content opt-in;
+ * - an EMBEDDING consumes input tokens and produces VECTORS; it has no completion-token
+ *   dimension (so completeness is judged on input tokens alone), and its output must NEVER
+ *   reach analytics or logs at any verbosity — a vector is a lossy encoding of the source text,
+ *   not telemetry. Producers put a `{ vectorCount, dims }` summary in `output`; sinks enforce
+ *   the exclusion defensively on top.
+ *
+ * Absent means GENERATION (every pre-existing producer), so the field is additive.
+ */
+export declare enum AgentCallTraceKind {
+    GENERATION = "generation",
+    EMBEDDING = "embedding"
+}
+/**
+ * Structured, JSON-serializable shape for a failed agent call. (Never the raw
+ * `Error` object — it collapses to `{}` under `JSON.stringify`.)
+ */
+export declare const AgentCallTraceErrorSchema: z.ZodObject<{
+    name: z.ZodOptional<z.ZodString>;
+    message: z.ZodString;
+    code: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type AgentCallTraceError = z.infer<typeof AgentCallTraceErrorSchema>;
+/**
+ * The typed per-call trace record the engine emits to the configured sink, once
+ * per `invokeAgent` completion (success or failure). This is the contract that
+ * replaces every caller's hand-rolled `response.executionContext as { usage?,
+ * executionTime? }` cast + manual artifact write.
+ *
+ * - `context` reuses {@link LLMProvider_OperationContext_BaseSchema} — the exact
+ *   telemetry envelope (`usage` / `executionTime` / `finishedAt` / `finishReason`
+ *   / `transport` / `outputTracking`) that `invokeAgent` already assembles. No
+ *   parallel shape, no drift.
+ * - `input` / `output` are agent-specific and therefore opaque here; sinks
+ *   persist them only at `DEBUG_VERBOSE` (payload gating is a sink concern).
+ * - `attempt` lets a caller-side retry loop correlate multiple records for one
+ *   logical generation: the engine traces each physical call; retry orchestration
+ *   stays caller-side.
+ */
+export declare const AgentCallTraceSchema: z.ZodObject<{
+    agentRef: z.ZodString;
+    kind: z.ZodOptional<z.ZodEnum<typeof AgentCallTraceKind>>;
+    provider: z.ZodOptional<z.ZodString>;
+    model: z.ZodOptional<z.ZodString>;
+    callTimestamp: z.ZodString;
+    attempt: z.ZodOptional<z.ZodNumber>;
+    outcome: z.ZodEnum<typeof AgentCallOutcome>;
+    input: z.ZodOptional<z.ZodUnknown>;
+    output: z.ZodOptional<z.ZodUnknown>;
+    context: z.ZodOptional<z.ZodObject<{
+        callTimestamp: z.ZodISODateTime;
+        callDuration: z.ZodOptional<z.ZodNumber>;
+        errorReason: z.ZodOptional<z.ZodString>;
+        finishReason: z.ZodOptional<z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").LLMProvider_FinishReason>>;
+        usage: z.ZodOptional<z.ZodObject<{
+            promptTokens: z.ZodOptional<z.ZodNumber>;
+            completionTokens: z.ZodOptional<z.ZodNumber>;
+            totalTokens: z.ZodOptional<z.ZodNumber>;
+            tokenUsageComplete: z.ZodOptional<z.ZodBoolean>;
+            inputTokenDetails: z.ZodOptional<z.ZodObject<{
+                noCacheTokens: z.ZodOptional<z.ZodNumber>;
+                cacheReadTokens: z.ZodOptional<z.ZodNumber>;
+                cacheWriteTokens: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>>;
+        outputTracking: z.ZodOptional<z.ZodObject<{
+            toolsUsed: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                type: z.ZodEnum<{
+                    function: "function";
+                    mcp: "mcp";
+                }>;
+                ref: z.ZodString;
+                name: z.ZodString;
+                executionTime: z.ZodOptional<z.ZodNumber>;
+                input: z.ZodOptional<z.ZodUnknown>;
+                output: z.ZodOptional<z.ZodUnknown>;
+                error: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            toolCalls: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                arguments: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                result: z.ZodOptional<z.ZodUnknown>;
+                error: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>>;
+            mcpConnectionsUsed: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                ref: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                operationsExecuted: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    operation: z.ZodString;
+                    input: z.ZodOptional<z.ZodUnknown>;
+                    output: z.ZodOptional<z.ZodUnknown>;
+                    executionTime: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>>;
+            thinkingSteps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                stepNumber: z.ZodNumber;
+                thought: z.ZodOptional<z.ZodString>;
+                reasoning: z.ZodOptional<z.ZodString>;
+                conclusionReached: z.ZodOptional<z.ZodBoolean>;
+                tokensUsed: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>>;
+        executionTime: z.ZodOptional<z.ZodNumber>;
+        finishedAt: z.ZodOptional<z.ZodString>;
+        transport: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<import("@wildo-ai/external-connectors-models").LLMProvider_ExecutionTransportKind>;
+            protocolKind: z.ZodLiteral<import("@wildo-ai/external-connectors-models").ExternalProvider_ExchangeProtocol_Kind.LLM_PROVIDER>;
+            providerRef: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>], "kind">>;
+        structuredGenerationFailure: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<typeof import("@wildo-ai/external-connectors-models").LLMProvider_StructuredGenerationFailureKind>;
+            message: z.ZodString;
+            errorName: z.ZodOptional<z.ZodString>;
+            validationCauseName: z.ZodOptional<z.ZodString>;
+            validationIssues: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                code: z.ZodString;
+                path: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>;
+            }, z.core.$strip>>>;
+            finishReason: z.ZodOptional<z.ZodString>;
+            generatedTextLength: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            rootKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodObject<{
+        name: z.ZodOptional<z.ZodString>;
+        message: z.ZodString;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type AgentCallTrace = z.infer<typeof AgentCallTraceSchema>;
+/**
+ * Caller-supplied correlation + enrichment, handed to `invokeAgent` so the
+ * emitted {@link AgentCallTraceSchema} record can be routed and contextualized
+ * by the sink.
+ *
+ * The engine does NOT interpret `sessionRef` / `stepRef` — they are opaque
+ * handles the sink owns (e.g. the companion filesystem sink's session/step
+ * directory ids). `attributes` carry caller domain context (templateRef,
+ * locale, bucket, …) for filtering/grouping.
+ */
+export declare const AgentTraceContextSchema: z.ZodObject<{
+    sessionRef: z.ZodOptional<z.ZodString>;
+    stepRef: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+    attributes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    levelOverride: z.ZodOptional<z.ZodEnum<typeof AgentTraceabilityLevel>>;
+}, z.core.$strip>;
+export type AgentTraceContext = z.infer<typeof AgentTraceContextSchema>;
+/**
+ * One agent-call trace emission handed to a sink: the typed per-call record, the
+ * engine-resolved active level (never `NONE` — the engine skips emission at `NONE`),
+ * and the caller's correlation/enrichment context. Bundled so sinks gain fields
+ * without a signature change.
+ */
+export interface AgentCallTraceEmission {
+    trace: AgentCallTrace;
+    level: AgentTraceabilityLevel;
+    context?: AgentTraceContext;
+}
+/**
+ * Pluggable destination for engine-level agent-call traces — the swappable output
+ * side of `AgentsBackendService.invokeAgent` tracing (filesystem artifacts, structured
+ * logs, 3rd-party LLM analytics, OTel spans, …).
+ *
+ * The interface lives in `saas-models` (not a backend package) so implementations can
+ * live where their dependency belongs WITHOUT a dependency cycle: generic ones in
+ * `saas-backend-lib` (NoOp / Logger / Composite), provider-specific ones in
+ * `external-connectors-private` (e.g. the PostHog LLM-analytics sink, which owns
+ * `posthog-node`), app-specific ones in the app (e.g. the companion filesystem sink).
+ *
+ * `recordAgentCall` MUST be best-effort: the engine wraps it so a sink failure never
+ * turns a successful agent call into a failed one, and output is byte-identical when
+ * traceability is off.
+ */
+export interface AgentCallTraceSink {
+    recordAgentCall(emission: AgentCallTraceEmission): void | Promise<void>;
+    /**
+     * Optional flush/cleanup, called best-effort on host shutdown. Implementations
+     * that batch + flush asynchronously (e.g. a 3rd-party analytics client) MUST drain
+     * here so short-lived processes (CLI / companion / minion) don't lose queued events.
+     */
+    shutdown?(): void | Promise<void>;
+}
+//# sourceMappingURL=agent-traceability.shared.schemas.d.ts.map

package/dist/esm/flows-actors/agent-traceability.shared.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-traceability.shared.schemas.d.ts","sourceRoot":"","sources":["../../../../src/flows-actors/agent-traceability.shared.schemas.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;;;;;GAUG;AACH,oBAAY,sBAAsB;IAChC,IAAI,SAAS;IACb,KAAK,UAAU;IACf,aAAa,kBAAkB;CAChC;AAED,wEAAwE;AACxE,eAAO,MAAM,8BAA8B,EAAE,MAAM,CAAC,sBAAsB,EAAE,MAAM,CAIjF,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,4BAA4B,CAC1C,WAAW,EAAE,sBAAsB,EACnC,YAAY,EAAE,sBAAsB,GACnC,OAAO,CAET;AAED;;;;;;;;GAQG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,EAAE,sBAAsB,EACzB,CAAC,EAAE,sBAAsB,GACxB,sBAAsB,CAExB;AAED,4EAA4E;AAC5E,eAAO,MAAM,6BAA6B;;iBAExC,CAAC;AACH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,qDAAqD;AACrD,oBAAY,gBAAgB;IAC1B,OAAO,YAAY;IACnB,OAAO,YAAY;CACpB;AAED;;;;;;;;;;;;;;GAcG;AACH,oBAAY,kBAAkB;IAC5B,UAAU,eAAe;IACzB,SAAS,cAAc;CACxB;AAED;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;iBAIpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4B/B,CAAC;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAElE;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB;;;;;;iBAWlC,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAExE;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACrC,KAAK,EAAE,cAAc,CAAC;IACtB,KAAK,EAAE,sBAAsB,CAAC;IAC9B,OAAO,CAAC,EAAE,iBAAiB,CAAC;CAC7B;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,kBAAkB;IACjC,eAAe,CAAC,QAAQ,EAAE,sBAAsB,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IACxE;;;;OAIG;IACH,QAAQ,CAAC,IAAI,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnC"}

package/dist/esm/flows-actors/agent-traceability.shared.schemas.js

@@ -0,0 +1,152 @@
+import { z } from 'zod';
+import { LLMProvider_OperationContext_BaseSchema } from '@wildo-ai/external-connectors-models';
+/**
+ * Verbosity policy for engine-level agent-call traceability. Promotes the
+ * companion's previously-local `WILDO_DEV_COMPANION_TRACEABILITY_LEVEL` to a
+ * shared engine contract so every agent caller (companion, backend runtime,
+ * minions, workers) and every sink (filesystem, logger, OTel) speak the same
+ * levels.
+ *
+ * - `NONE`          — tracing fully off; emitters must no-op before any I/O.
+ * - `DEBUG`         — per-call metadata + token usage + latency (no payloads).
+ * - `DEBUG_VERBOSE` — adds the resolved prompt input + raw output payloads.
+ */
+export var AgentTraceabilityLevel;
+(function (AgentTraceabilityLevel) {
+    AgentTraceabilityLevel["NONE"] = "NONE";
+    AgentTraceabilityLevel["DEBUG"] = "DEBUG";
+    AgentTraceabilityLevel["DEBUG_VERBOSE"] = "DEBUG_VERBOSE";
+})(AgentTraceabilityLevel || (AgentTraceabilityLevel = {}));
+/** Numeric ordering for `AgentTraceabilityLevel` gating comparisons. */
+export const AGENT_TRACEABILITY_LEVEL_ORDER = {
+    [AgentTraceabilityLevel.NONE]: 0,
+    [AgentTraceabilityLevel.DEBUG]: 1,
+    [AgentTraceabilityLevel.DEBUG_VERBOSE]: 2,
+};
+/**
+ * True when `activeLevel` is at least `minimumLevel` — the canonical gate every
+ * sink/emitter uses so a record is persisted only when the active policy meets
+ * the record's minimum verbosity.
+ */
+export function agentTraceabilityLevelAllows(activeLevel, minimumLevel) {
+    return AGENT_TRACEABILITY_LEVEL_ORDER[activeLevel] >= AGENT_TRACEABILITY_LEVEL_ORDER[minimumLevel];
+}
+/**
+ * The more verbose of two levels — for hosts that COMPOSE traceability
+ * concerns behind one policy binding. A host policy must never be LESS
+ * verbose than any interested sink: a companion whose filesystem tracing is
+ * off (`NONE`) but whose LLM-observability provider is active still needs
+ * `DEBUG` so the emission reaches the sinks (each sink then self-gates).
+ * Replacing a live policy with a static lower level silently kills every
+ * downstream sink — the failure mode that motivated this helper.
+ */
+export function maxAgentTraceabilityLevel(a, b) {
+    return AGENT_TRACEABILITY_LEVEL_ORDER[a] >= AGENT_TRACEABILITY_LEVEL_ORDER[b] ? a : b;
+}
+/** Engine-resolved traceability policy handed to `AgentsBackendService`. */
+export const AgentTraceabilityPolicySchema = z.object({
+    level: z.enum(AgentTraceabilityLevel).default(AgentTraceabilityLevel.NONE),
+});
+/** Terminal outcome of a single agent invocation. */
+export var AgentCallOutcome;
+(function (AgentCallOutcome) {
+    AgentCallOutcome["SUCCESS"] = "success";
+    AgentCallOutcome["FAILURE"] = "failure";
+})(AgentCallOutcome || (AgentCallOutcome = {}));
+/**
+ * WHAT KIND of model call a trace records — the operation-aware axis observability sinks branch
+ * on (RAG plan DL2/H4). The two kinds differ structurally, not cosmetically:
+ *
+ * - a GENERATION consumes prompt tokens and produces completion tokens; its usage is complete
+ *   only when BOTH dimensions are present, and its payload (prompt/completion text) may be
+ *   forwarded to analytics under an explicit content opt-in;
+ * - an EMBEDDING consumes input tokens and produces VECTORS; it has no completion-token
+ *   dimension (so completeness is judged on input tokens alone), and its output must NEVER
+ *   reach analytics or logs at any verbosity — a vector is a lossy encoding of the source text,
+ *   not telemetry. Producers put a `{ vectorCount, dims }` summary in `output`; sinks enforce
+ *   the exclusion defensively on top.
+ *
+ * Absent means GENERATION (every pre-existing producer), so the field is additive.
+ */
+export var AgentCallTraceKind;
+(function (AgentCallTraceKind) {
+    AgentCallTraceKind["GENERATION"] = "generation";
+    AgentCallTraceKind["EMBEDDING"] = "embedding";
+})(AgentCallTraceKind || (AgentCallTraceKind = {}));
+/**
+ * Structured, JSON-serializable shape for a failed agent call. (Never the raw
+ * `Error` object — it collapses to `{}` under `JSON.stringify`.)
+ */
+export const AgentCallTraceErrorSchema = z.object({
+    name: z.string().optional(),
+    message: z.string(),
+    code: z.string().optional(),
+});
+/**
+ * The typed per-call trace record the engine emits to the configured sink, once
+ * per `invokeAgent` completion (success or failure). This is the contract that
+ * replaces every caller's hand-rolled `response.executionContext as { usage?,
+ * executionTime? }` cast + manual artifact write.
+ *
+ * - `context` reuses {@link LLMProvider_OperationContext_BaseSchema} — the exact
+ *   telemetry envelope (`usage` / `executionTime` / `finishedAt` / `finishReason`
+ *   / `transport` / `outputTracking`) that `invokeAgent` already assembles. No
+ *   parallel shape, no drift.
+ * - `input` / `output` are agent-specific and therefore opaque here; sinks
+ *   persist them only at `DEBUG_VERBOSE` (payload gating is a sink concern).
+ * - `attempt` lets a caller-side retry loop correlate multiple records for one
+ *   logical generation: the engine traces each physical call; retry orchestration
+ *   stays caller-side.
+ */
+export const AgentCallTraceSchema = z.object({
+    agentRef: z.string(),
+    /** See {@link AgentCallTraceKind}. Absent = `GENERATION` (the pre-existing producers). */
+    kind: z.enum(AgentCallTraceKind).optional(),
+    /**
+     * Resolved LLM vendor ref (e.g. `anthropic`, `openai`). Maps to analytics
+     * dimensions like PostHog `$ai_provider`. Optional — non-LLM/uncaptured calls omit it.
+     */
+    provider: z.string().optional(),
+    /**
+     * Resolved model id (e.g. `claude-opus-4-8`). Load-bearing for analytics sinks:
+     * PostHog derives `$ai_total_cost_usd` from `$ai_model` + token usage, so without
+     * it cost attribution is lost. Optional — populated for model-backed agent calls.
+     */
+    model: z.string().optional(),
+    /** ISO 8601 — when the call was initiated. */
+    callTimestamp: z.string(),
+    /** 1-based attempt index when the caller drives a retry loop. */
+    attempt: z.number().int().positive().optional(),
+    outcome: z.enum(AgentCallOutcome),
+    /** Resolved agent input (e.g. the prompt). Opaque; sink persists at DEBUG_VERBOSE. */
+    input: z.unknown().optional(),
+    /** Raw agent output. Opaque; sink persists at DEBUG_VERBOSE. */
+    output: z.unknown().optional(),
+    /** Telemetry the engine captured — token usage, latency, transport, finishReason. */
+    context: LLMProvider_OperationContext_BaseSchema.optional(),
+    /** Present on `FAILURE`. */
+    error: AgentCallTraceErrorSchema.optional(),
+});
+/**
+ * Caller-supplied correlation + enrichment, handed to `invokeAgent` so the
+ * emitted {@link AgentCallTraceSchema} record can be routed and contextualized
+ * by the sink.
+ *
+ * The engine does NOT interpret `sessionRef` / `stepRef` — they are opaque
+ * handles the sink owns (e.g. the companion filesystem sink's session/step
+ * directory ids). `attributes` carry caller domain context (templateRef,
+ * locale, bucket, …) for filtering/grouping.
+ */
+export const AgentTraceContextSchema = z.object({
+    /** Opaque sink-owned session handle (groups many calls of one operation). */
+    sessionRef: z.string().optional(),
+    /** Opaque sink-owned step handle (one logical sub-operation within a session). */
+    stepRef: z.string().optional(),
+    /** Human-readable label (e.g. `email-template-generation:system.welcome_email`). */
+    label: z.string().optional(),
+    /** Caller domain attributes for filtering/grouping (templateRef, locale, …). */
+    attributes: z.record(z.string(), z.unknown()).optional(),
+    /** Per-call override of the engine policy level (else the engine default applies). */
+    levelOverride: z.enum(AgentTraceabilityLevel).optional(),
+});
+//# sourceMappingURL=agent-traceability.shared.schemas.js.map

package/dist/esm/flows-actors/agent-traceability.shared.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-traceability.shared.schemas.js","sourceRoot":"","sources":["../../../../src/flows-actors/agent-traceability.shared.schemas.ts"],"names":[],"mappings":"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","sourcesContent":["import { z } from 'zod';\nimport { LLMProvider_OperationContext_BaseSchema } from '@wildo-ai/external-connectors-models';\n\n/**\n * Verbosity policy for engine-level agent-call traceability. Promotes the\n * companion's previously-local `WILDO_DEV_COMPANION_TRACEABILITY_LEVEL` to a\n * shared engine contract so every agent caller (companion, backend runtime,\n * minions, workers) and every sink (filesystem, logger, OTel) speak the same\n * levels.\n *\n * - `NONE`          — tracing fully off; emitters must no-op before any I/O.\n * - `DEBUG`         — per-call metadata + token usage + latency (no payloads).\n * - `DEBUG_VERBOSE` — adds the resolved prompt input + raw output payloads.\n */\nexport enum AgentTraceabilityLevel {\n  NONE = 'NONE',\n  DEBUG = 'DEBUG',\n  DEBUG_VERBOSE = 'DEBUG_VERBOSE',\n}\n\n/** Numeric ordering for `AgentTraceabilityLevel` gating comparisons. */\nexport const AGENT_TRACEABILITY_LEVEL_ORDER: Record<AgentTraceabilityLevel, number> = {\n  [AgentTraceabilityLevel.NONE]: 0,\n  [AgentTraceabilityLevel.DEBUG]: 1,\n  [AgentTraceabilityLevel.DEBUG_VERBOSE]: 2,\n};\n\n/**\n * True when `activeLevel` is at least `minimumLevel` — the canonical gate every\n * sink/emitter uses so a record is persisted only when the active policy meets\n * the record's minimum verbosity.\n */\nexport function agentTraceabilityLevelAllows(\n  activeLevel: AgentTraceabilityLevel,\n  minimumLevel: AgentTraceabilityLevel,\n): boolean {\n  return AGENT_TRACEABILITY_LEVEL_ORDER[activeLevel] >= AGENT_TRACEABILITY_LEVEL_ORDER[minimumLevel];\n}\n\n/**\n * The more verbose of two levels — for hosts that COMPOSE traceability\n * concerns behind one policy binding. A host policy must never be LESS\n * verbose than any interested sink: a companion whose filesystem tracing is\n * off (`NONE`) but whose LLM-observability provider is active still needs\n * `DEBUG` so the emission reaches the sinks (each sink then self-gates).\n * Replacing a live policy with a static lower level silently kills every\n * downstream sink — the failure mode that motivated this helper.\n */\nexport function maxAgentTraceabilityLevel(\n  a: AgentTraceabilityLevel,\n  b: AgentTraceabilityLevel,\n): AgentTraceabilityLevel {\n  return AGENT_TRACEABILITY_LEVEL_ORDER[a] >= AGENT_TRACEABILITY_LEVEL_ORDER[b] ? a : b;\n}\n\n/** Engine-resolved traceability policy handed to `AgentsBackendService`. */\nexport const AgentTraceabilityPolicySchema = z.object({\n  level: z.enum(AgentTraceabilityLevel).default(AgentTraceabilityLevel.NONE),\n});\nexport type AgentTraceabilityPolicy = z.infer<typeof AgentTraceabilityPolicySchema>;\n\n/** Terminal outcome of a single agent invocation. */\nexport enum AgentCallOutcome {\n  SUCCESS = 'success',\n  FAILURE = 'failure',\n}\n\n/**\n * WHAT KIND of model call a trace records — the operation-aware axis observability sinks branch\n * on (RAG plan DL2/H4). The two kinds differ structurally, not cosmetically:\n *\n * - a GENERATION consumes prompt tokens and produces completion tokens; its usage is complete\n *   only when BOTH dimensions are present, and its payload (prompt/completion text) may be\n *   forwarded to analytics under an explicit content opt-in;\n * - an EMBEDDING consumes input tokens and produces VECTORS; it has no completion-token\n *   dimension (so completeness is judged on input tokens alone), and its output must NEVER\n *   reach analytics or logs at any verbosity — a vector is a lossy encoding of the source text,\n *   not telemetry. Producers put a `{ vectorCount, dims }` summary in `output`; sinks enforce\n *   the exclusion defensively on top.\n *\n * Absent means GENERATION (every pre-existing producer), so the field is additive.\n */\nexport enum AgentCallTraceKind {\n  GENERATION = 'generation',\n  EMBEDDING = 'embedding',\n}\n\n/**\n * Structured, JSON-serializable shape for a failed agent call. (Never the raw\n * `Error` object — it collapses to `{}` under `JSON.stringify`.)\n */\nexport const AgentCallTraceErrorSchema = z.object({\n  name: z.string().optional(),\n  message: z.string(),\n  code: z.string().optional(),\n});\nexport type AgentCallTraceError = z.infer<typeof AgentCallTraceErrorSchema>;\n\n/**\n * The typed per-call trace record the engine emits to the configured sink, once\n * per `invokeAgent` completion (success or failure). This is the contract that\n * replaces every caller's hand-rolled `response.executionContext as { usage?,\n * executionTime? }` cast + manual artifact write.\n *\n * - `context` reuses {@link LLMProvider_OperationContext_BaseSchema} — the exact\n *   telemetry envelope (`usage` / `executionTime` / `finishedAt` / `finishReason`\n *   / `transport` / `outputTracking`) that `invokeAgent` already assembles. No\n *   parallel shape, no drift.\n * - `input` / `output` are agent-specific and therefore opaque here; sinks\n *   persist them only at `DEBUG_VERBOSE` (payload gating is a sink concern).\n * - `attempt` lets a caller-side retry loop correlate multiple records for one\n *   logical generation: the engine traces each physical call; retry orchestration\n *   stays caller-side.\n */\nexport const AgentCallTraceSchema = z.object({\n  agentRef: z.string(),\n  /** See {@link AgentCallTraceKind}. Absent = `GENERATION` (the pre-existing producers). */\n  kind: z.enum(AgentCallTraceKind).optional(),\n  /**\n   * Resolved LLM vendor ref (e.g. `anthropic`, `openai`). Maps to analytics\n   * dimensions like PostHog `$ai_provider`. Optional — non-LLM/uncaptured calls omit it.\n   */\n  provider: z.string().optional(),\n  /**\n   * Resolved model id (e.g. `claude-opus-4-8`). Load-bearing for analytics sinks:\n   * PostHog derives `$ai_total_cost_usd` from `$ai_model` + token usage, so without\n   * it cost attribution is lost. Optional — populated for model-backed agent calls.\n   */\n  model: z.string().optional(),\n  /** ISO 8601 — when the call was initiated. */\n  callTimestamp: z.string(),\n  /** 1-based attempt index when the caller drives a retry loop. */\n  attempt: z.number().int().positive().optional(),\n  outcome: z.enum(AgentCallOutcome),\n  /** Resolved agent input (e.g. the prompt). Opaque; sink persists at DEBUG_VERBOSE. */\n  input: z.unknown().optional(),\n  /** Raw agent output. Opaque; sink persists at DEBUG_VERBOSE. */\n  output: z.unknown().optional(),\n  /** Telemetry the engine captured — token usage, latency, transport, finishReason. */\n  context: LLMProvider_OperationContext_BaseSchema.optional(),\n  /** Present on `FAILURE`. */\n  error: AgentCallTraceErrorSchema.optional(),\n});\nexport type AgentCallTrace = z.infer<typeof AgentCallTraceSchema>;\n\n/**\n * Caller-supplied correlation + enrichment, handed to `invokeAgent` so the\n * emitted {@link AgentCallTraceSchema} record can be routed and contextualized\n * by the sink.\n *\n * The engine does NOT interpret `sessionRef` / `stepRef` — they are opaque\n * handles the sink owns (e.g. the companion filesystem sink's session/step\n * directory ids). `attributes` carry caller domain context (templateRef,\n * locale, bucket, …) for filtering/grouping.\n */\nexport const AgentTraceContextSchema = z.object({\n  /** Opaque sink-owned session handle (groups many calls of one operation). */\n  sessionRef: z.string().optional(),\n  /** Opaque sink-owned step handle (one logical sub-operation within a session). */\n  stepRef: z.string().optional(),\n  /** Human-readable label (e.g. `email-template-generation:system.welcome_email`). */\n  label: z.string().optional(),\n  /** Caller domain attributes for filtering/grouping (templateRef, locale, …). */\n  attributes: z.record(z.string(), z.unknown()).optional(),\n  /** Per-call override of the engine policy level (else the engine default applies). */\n  levelOverride: z.enum(AgentTraceabilityLevel).optional(),\n});\nexport type AgentTraceContext = z.infer<typeof AgentTraceContextSchema>;\n\n/**\n * One agent-call trace emission handed to a sink: the typed per-call record, the\n * engine-resolved active level (never `NONE` — the engine skips emission at `NONE`),\n * and the caller's correlation/enrichment context. Bundled so sinks gain fields\n * without a signature change.\n */\nexport interface AgentCallTraceEmission {\n  trace: AgentCallTrace;\n  level: AgentTraceabilityLevel;\n  context?: AgentTraceContext;\n}\n\n/**\n * Pluggable destination for engine-level agent-call traces — the swappable output\n * side of `AgentsBackendService.invokeAgent` tracing (filesystem artifacts, structured\n * logs, 3rd-party LLM analytics, OTel spans, …).\n *\n * The interface lives in `saas-models` (not a backend package) so implementations can\n * live where their dependency belongs WITHOUT a dependency cycle: generic ones in\n * `saas-backend-lib` (NoOp / Logger / Composite), provider-specific ones in\n * `external-connectors-private` (e.g. the PostHog LLM-analytics sink, which owns\n * `posthog-node`), app-specific ones in the app (e.g. the companion filesystem sink).\n *\n * `recordAgentCall` MUST be best-effort: the engine wraps it so a sink failure never\n * turns a successful agent call into a failed one, and output is byte-identical when\n * traceability is off.\n */\nexport interface AgentCallTraceSink {\n  recordAgentCall(emission: AgentCallTraceEmission): void | Promise<void>;\n  /**\n   * Optional flush/cleanup, called best-effort on host shutdown. Implementations\n   * that batch + flush asynchronously (e.g. a 3rd-party analytics client) MUST drain\n   * here so short-lived processes (CLI / companion / minion) don't lose queued events.\n   */\n  shutdown?(): void | Promise<void>;\n}\n"]}