@qodo/sdk 0.13.3 → 2.0.0-next.0

package/dist/qar/agentSpec.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Pre-wire validation helpers for `task.start { agent: InlineAgentSpec }`
+ * (Pattern B). The wire types themselves live in `./specs.ts`; this
+ * module carries the SDK-side intake guard plus a re-export of the
+ * `InlineAgentSpec` symbol under the `AgentSpec` alias.
+ *
+ * **Why an SDK-side intake guard?** QAR's `validate_spec_payload` is the
+ * single source of truth for spec rule_ids; the SDK never tries to
+ * reimplement the full ruleset. But two classes of failure are worth
+ * catching client-side without paying the round-trip:
+ *
+ *   1. **Forbidden keys.** `custom_code: { ... }` and unknown top-level
+ *      fields (`hooks`, `lifecycle`, anything not in the safe subset)
+ *      are deterministically rejected by `D10-R1` / `D10-R3` / `D10-R5`.
+ *      Catching them in TypeScript at intake means the consumer's stack
+ *      trace points at their call site; QAR's per-rule `path` is
+ *      preserved so the error message is identical to the wire envelope.
+ *   2. **Discriminator + required-field hygiene.** Missing
+ *      `apiVersion` / `instructions` / `model` (the only required
+ *      fields) gets a typed reject before the wire write so consumers
+ *      don't see a `task.done(failed)` 200ms later for a typo they
+ *      could have caught at edit time.
+ *
+ * Per-rule semantic checks (catalog name resolution, skill compatibility,
+ * spawnable agent registry lookups, etc.) stay server-side — they need
+ * tenant context the SDK doesn't have.
+ */
+import type { InlineAgentSpec } from './specs.js';
+/**
+ * Pre-wire validation outcome — one entry per detected violation. Matches
+ * the per-rule shape QAR emits via `agent_spec_rejected` envelopes so
+ * consumers handling both paths can branch on the same `(rule_id, path,
+ * message)` triple.
+ */
+export interface InlineAgentSpecValidationIssue {
+    readonly rule_id: string;
+    /** JSON Pointer (RFC 6901) into the spec — `""` for root. */
+    readonly path: string;
+    readonly message: string;
+}
+/**
+ * Walk an `unknown` value asserted to be an `InlineAgentSpec`, returning
+ * the list of detected pre-wire violations. Empty list = pre-wire-clean
+ * (still subject to the server's per-rule pass at `task.start` and the
+ * pre-flight endpoint).
+ *
+ * Field-shape validation is intentionally shallow: we check the rules a
+ * dumb JSON walker can verify (forbidden keys, missing required scalars,
+ * `custom_code !== null`). Deeper composition rules (skill version
+ * resolution, spawnable agent registry, tool-name collisions) need
+ * tenant context and stay server-side under `validate_spec_payload`.
+ */
+export declare function collectInlineAgentSpecPreWireIssues(spec: unknown): readonly InlineAgentSpecValidationIssue[];
+/**
+ * Type-guard form of `collectInlineAgentSpecPreWireIssues`. Throws
+ * `QodoInlineAgentValidationError` from `../client/errors.js` when any
+ * pre-wire issue is detected. Caller is `TaskClient.start` —
+ * `assertInlineAgentSpecPreWire(payload.agent)` runs before any wire
+ * write so the consumer's stack trace points at the call site, not at a
+ * `task.done(failed)` arriving over the wire.
+ *
+ * Lives in this module (not in the central `errors.ts`) because circular
+ * imports are easier to avoid when the assertion sits next to the rule
+ * walker that produces its message body.
+ */
+export declare function assertInlineAgentSpecPreWire(spec: unknown): asserts spec is InlineAgentSpec;
+/**
+ * Fill in the wire-canonical `kind: 'AgentSpec'` discriminator when the
+ * consumer's spec omits it. `InlineAgentSpec.kind` is optional in TypeScript
+ * — required server-side, but the SDK is permissive at the type level so
+ * consumers can write `{ apiVersion, instructions, model }` literally.
+ * Both `task.start` dispatch and `specs.validate` need the discriminator
+ * on the wire, so this normalizer runs at every wire boundary.
+ *
+ * Doesn't mutate the consumer's input object — returns the same reference if
+ * `kind` is already set so the spread cost is paid only when needed.
+ */
+export declare function normalizeInlineAgentSpec(spec: InlineAgentSpec): InlineAgentSpec;
+/**
+ * The inline `AgentSpec` symbol — exported here so consumers can
+ * `import { AgentSpec }` for the wire shape, even though
+ * `QarRegistryClient.AgentSpec` (the local-registry shape) owns the
+ * unqualified `AgentSpec` export at the package index. Two layers, two
+ * types — see `./specs.ts` header for the longer rationale.
+ *
+ * Marked deprecated only as a hint that direct use should prefer
+ * `InlineAgentSpec` to keep the wire-vs-local distinction visible at the
+ * call site; the alias itself isn't going anywhere.
+ *
+ * @see {@link InlineAgentSpec}
+ */
+export type AgentSpec = InlineAgentSpec;
+//# sourceMappingURL=agentSpec.d.ts.map

package/dist/qar/agentSpec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentSpec.d.ts","sourceRoot":"","sources":["../../src/qar/agentSpec.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAmClD;;;;;GAKG;AACH,MAAM,WAAW,8BAA8B;IAC7C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,6DAA6D;IAC7D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mCAAmC,CACjD,IAAI,EAAE,OAAO,GACZ,SAAS,8BAA8B,EAAE,CAsF3C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,OAAO,GACZ,OAAO,CAAC,IAAI,IAAI,eAAe,CAIjC;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,eAAe,GAAG,eAAe,CAG/E;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,SAAS,GAAG,eAAe,CAAC"}

package/dist/qar/agentSpec.js

@@ -0,0 +1,184 @@
+/**
+ * Pre-wire validation helpers for `task.start { agent: InlineAgentSpec }`
+ * (Pattern B). The wire types themselves live in `./specs.ts`; this
+ * module carries the SDK-side intake guard plus a re-export of the
+ * `InlineAgentSpec` symbol under the `AgentSpec` alias.
+ *
+ * **Why an SDK-side intake guard?** QAR's `validate_spec_payload` is the
+ * single source of truth for spec rule_ids; the SDK never tries to
+ * reimplement the full ruleset. But two classes of failure are worth
+ * catching client-side without paying the round-trip:
+ *
+ *   1. **Forbidden keys.** `custom_code: { ... }` and unknown top-level
+ *      fields (`hooks`, `lifecycle`, anything not in the safe subset)
+ *      are deterministically rejected by `D10-R1` / `D10-R3` / `D10-R5`.
+ *      Catching them in TypeScript at intake means the consumer's stack
+ *      trace points at their call site; QAR's per-rule `path` is
+ *      preserved so the error message is identical to the wire envelope.
+ *   2. **Discriminator + required-field hygiene.** Missing
+ *      `apiVersion` / `instructions` / `model` (the only required
+ *      fields) gets a typed reject before the wire write so consumers
+ *      don't see a `task.done(failed)` 200ms later for a typo they
+ *      could have caught at edit time.
+ *
+ * Per-rule semantic checks (catalog name resolution, skill compatibility,
+ * spawnable agent registry lookups, etc.) stay server-side — they need
+ * tenant context the SDK doesn't have.
+ */
+import { QodoInlineAgentValidationError } from '../client/errors.js';
+/** Allowed top-level field set. Anything else triggers `D10-R5`. */
+const ALLOWED_AGENT_SPEC_FIELDS = new Set([
+    'apiVersion',
+    'kind',
+    'name',
+    'instructions',
+    'model',
+    'tools',
+    'use_managed_tools',
+    'excluded_tools',
+    'output_schema',
+    'deps_schema',
+    'skills',
+    'spawnable_agents',
+    'custom_code',
+    // Content-trust policy. Threads through to QAR's
+    // `AgentSpec.content_trust` field.
+    'content_trust',
+    // Chat-mode primitive. Boolean, default `false`. Pre-wire validator
+    // accepts the field; QAR's `validate_spec_payload` is the canonical
+    // type check (rejects non-bool via Pydantic `value_error.bool_type`).
+    'auto_pause_on_turn_end',
+    // MCP tool auto-discovery — SDK-only fields. The projection layer at
+    // `tasks.startWithAgent` / `tasks.startWithGraph` resolves `mcpTools`
+    // against the live `McpClientPool` catalog and strips both fields
+    // before the wire write so QAR never sees them. The pre-wire
+    // validator accepts them here so consumers writing the consumer-side
+    // ergonomic don't trip on the AgentSpec extra-field rule for an
+    // SDK-only surface.
+    'mcpTools',
+    'mcpToolOverrides',
+]);
+/**
+ * Walk an `unknown` value asserted to be an `InlineAgentSpec`, returning
+ * the list of detected pre-wire violations. Empty list = pre-wire-clean
+ * (still subject to the server's per-rule pass at `task.start` and the
+ * pre-flight endpoint).
+ *
+ * Field-shape validation is intentionally shallow: we check the rules a
+ * dumb JSON walker can verify (forbidden keys, missing required scalars,
+ * `custom_code !== null`). Deeper composition rules (skill version
+ * resolution, spawnable agent registry, tool-name collisions) need
+ * tenant context and stay server-side under `validate_spec_payload`.
+ */
+export function collectInlineAgentSpecPreWireIssues(spec) {
+    const issues = [];
+    if (typeof spec !== 'object' || spec === null || Array.isArray(spec)) {
+        issues.push({
+            rule_id: 'D10-R5',
+            path: '',
+            message: 'AgentSpec must be a JSON object',
+        });
+        return issues;
+    }
+    const obj = spec;
+    // D10-R1 — `custom_code` reserved; only `null` is acceptable. Any
+    // truthy value (string, object, boolean) is rejected.
+    if ('custom_code' in obj && obj.custom_code !== null && obj.custom_code !== undefined) {
+        issues.push({
+            rule_id: 'D10-R1',
+            path: '/custom_code',
+            message: 'custom_code is reserved-and-rejected until the sandboxed-execution ADR ships; set to null or omit',
+        });
+    }
+    // D10-R5 — unknown top-level fields. Catches `hooks` / `lifecycle`
+    // (D10-R3 in practice — both shapes are rejected as unknown
+    // top-level fields under QAR's `extra="forbid"` Pydantic config) and
+    // the legacy 1.x `customPythonAgentPath` shape.
+    for (const key of Object.keys(obj)) {
+        if (!ALLOWED_AGENT_SPEC_FIELDS.has(key)) {
+            issues.push({
+                rule_id: key === 'hooks' || key === 'lifecycle' ? 'D10-R3' : 'D10-R5',
+                path: `/${key}`,
+                message: `AgentSpec contains forbidden top-level field "${key}"`,
+            });
+        }
+    }
+    // Required-field hygiene. Pydantic on the server reports these as
+    // `value_error.missing`; the SDK's pre-wire form gives them a
+    // `D10-SHAPE` synthetic rule_id so consumers can branch on
+    // structural vs semantic failures uniformly. Distinct prefix
+    // (`D10-SHAPE-*`) keeps them out of the wire `D10-R*` namespace QAR
+    // owns — we don't want SDK pre-wire ids drifting into QAR's
+    // documented ruleset.
+    if (typeof obj.apiVersion !== 'string' || obj.apiVersion.length === 0) {
+        issues.push({
+            rule_id: 'D10-SHAPE-APIVERSION',
+            path: '/apiVersion',
+            message: 'AgentSpec.apiVersion is required; set to "qar/v1"',
+        });
+    }
+    else if (obj.apiVersion !== 'qar/v1') {
+        issues.push({
+            rule_id: 'D10-SHAPE-APIVERSION',
+            path: '/apiVersion',
+            message: `AgentSpec.apiVersion must be "qar/v1"; got ${JSON.stringify(obj.apiVersion)}`,
+        });
+    }
+    if ('kind' in obj && obj.kind !== 'AgentSpec' && obj.kind !== undefined) {
+        issues.push({
+            rule_id: 'D10-SHAPE-KIND',
+            path: '/kind',
+            message: `AgentSpec.kind must be "AgentSpec" or omitted; got ${JSON.stringify(obj.kind)}`,
+        });
+    }
+    if (obj.instructions === undefined || obj.instructions === null) {
+        issues.push({
+            rule_id: 'D10-SHAPE-INSTRUCTIONS',
+            path: '/instructions',
+            message: 'AgentSpec.instructions is required (string or { preset: "qodo-default", append? })',
+        });
+    }
+    if (typeof obj.model !== 'string' || obj.model.length === 0) {
+        issues.push({
+            rule_id: 'D10-SHAPE-MODEL',
+            path: '/model',
+            message: 'AgentSpec.model is required (non-empty litellm:<provider>:<model> slug)',
+        });
+    }
+    return issues;
+}
+/**
+ * Type-guard form of `collectInlineAgentSpecPreWireIssues`. Throws
+ * `QodoInlineAgentValidationError` from `../client/errors.js` when any
+ * pre-wire issue is detected. Caller is `TaskClient.start` —
+ * `assertInlineAgentSpecPreWire(payload.agent)` runs before any wire
+ * write so the consumer's stack trace points at the call site, not at a
+ * `task.done(failed)` arriving over the wire.
+ *
+ * Lives in this module (not in the central `errors.ts`) because circular
+ * imports are easier to avoid when the assertion sits next to the rule
+ * walker that produces its message body.
+ */
+export function assertInlineAgentSpecPreWire(spec) {
+    const issues = collectInlineAgentSpecPreWireIssues(spec);
+    if (issues.length === 0)
+        return;
+    throw new QodoInlineAgentValidationError(issues);
+}
+/**
+ * Fill in the wire-canonical `kind: 'AgentSpec'` discriminator when the
+ * consumer's spec omits it. `InlineAgentSpec.kind` is optional in TypeScript
+ * — required server-side, but the SDK is permissive at the type level so
+ * consumers can write `{ apiVersion, instructions, model }` literally.
+ * Both `task.start` dispatch and `specs.validate` need the discriminator
+ * on the wire, so this normalizer runs at every wire boundary.
+ *
+ * Doesn't mutate the consumer's input object — returns the same reference if
+ * `kind` is already set so the spread cost is paid only when needed.
+ */
+export function normalizeInlineAgentSpec(spec) {
+    if (spec.kind === 'AgentSpec')
+        return spec;
+    return { ...spec, kind: 'AgentSpec' };
+}
+//# sourceMappingURL=agentSpec.js.map

package/dist/qar/agentSpec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agentSpec.js","sourceRoot":"","sources":["../../src/qar/agentSpec.ts"],"names":[],"mappings":"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"}

package/dist/qar/clientEvents.d.ts

@@ -0,0 +1,86 @@
+/**
+ * SDK-internal lifecycle events surfaced on the canonical `TaskEvent` iterator
+ * and on `client.receive()`.
+ *
+ * These are NOT QAR envelope kinds — the `qar.client.*` namespace makes them
+ * unambiguously SDK-side so a stray server-side discriminant can never collide
+ * with one. They have no `message_id`, no `session_id`, no `payload` shape.
+ *
+ * The current set: `qar.client.reconnecting` / `qar.client.reconnected`
+ * / `qar.client.reconnect_failed` for transport-loss recovery, plus
+ * `qar.client.cancel_acked` synthesized from inbound `task.canceling`
+ * envelopes so consumers can render the "cancel acknowledged, awaiting
+ * terminal" intermediate state without expanding the `TaskEvent`
+ * switch. `kind` is the stable forward-compatible discriminator.
+ */
+import type { TaskId } from './ids.js';
+/** A reconnect attempt is about to fire. Emitted before the backoff sleep. */
+export interface ClientReconnectingEvent {
+    readonly kind: 'qar.client.reconnecting';
+    /** 1-based attempt counter — `1` is the first retry after the drop. */
+    readonly attempt: number;
+    /** Delay in milliseconds before this attempt fires. */
+    readonly delayMs: number;
+    /** Best-effort cause describing why we're reconnecting (close code, error message). */
+    readonly cause?: string;
+}
+/** A reconnect attempt succeeded. Emitted before any replayed envelopes flow. */
+export interface ClientReconnectedEvent {
+    readonly kind: 'qar.client.reconnected';
+    /** 1-based attempt counter that succeeded. */
+    readonly attempt: number;
+}
+/** Reconnect attempts exhausted. Subscriptions error out after this. */
+export interface ClientReconnectFailedEvent {
+    readonly kind: 'qar.client.reconnect_failed';
+    /** Total attempts made before giving up — same as `ClientReconnectOptions.maxAttempts`. */
+    readonly attempts: number;
+    /** Best-effort message from the last failed attempt. */
+    readonly lastError?: string;
+}
+/**
+ * Cancellation acknowledged by the SDK.
+ *
+ * Synthesized one-to-one from an inbound `task.canceling` envelope on the
+ * wire — the SDK converts the envelope's payload fields into this client
+ * event before broadcasting to subscriptions. Surfaces on the canonical
+ * `AsyncIterable<TaskEvent>` so a consumer waiting on the iterator can
+ * render the "cancel ack received, waiting for terminal `task.done`"
+ * intermediate state.
+ *
+ * Informational only — terminal status still arrives as `task.done
+ * { status: 'canceled' | 'failed' }`. Do not branch business logic on
+ * the pod identifiers; they're best-effort and may change between
+ * deployments.
+ *
+ * Surfaced as a synthetic client event rather than a first-class
+ * `TaskEvent` variant — keeps the consumer `switch (event.kind)`
+ * surface stable; consumers who don't care about cancel-ack just don't
+ * add the case.
+ */
+export interface ClientCancelAckedEvent {
+    readonly kind: 'qar.client.cancel_acked';
+    /** Task whose cancellation was acknowledged (always populated). */
+    readonly task_id: TaskId;
+    /** Pod that initially received the `task.cancel`. Opaque; advisory. */
+    readonly receivedByPod?: string;
+    /** Pod that owns the task right now. Opaque; advisory. */
+    readonly owningPod?: string;
+    /** Echo of the original `TaskCancelPayload.reason`, if any. */
+    readonly cancelReason?: string;
+    /** Best-effort SLO hint for time until terminal `task.done` arrives. Advisory. */
+    readonly expectedTerminalWithinS?: number;
+}
+export type ClientEvent = ClientReconnectingEvent | ClientReconnectedEvent | ClientReconnectFailedEvent | ClientCancelAckedEvent;
+/** Discriminator literal type covering every `ClientEvent` variant. */
+export type ClientEventKind = ClientEvent['kind'];
+/**
+ * Type guard: `true` for `qar.client.*` synthetic events.
+ *
+ * Accepts `unknown` so JS callers (or callers feeding raw deserialized JSON)
+ * can drop arbitrary values in without crashing on `null` / `undefined` /
+ * primitives. Only objects with a string `kind` matching one of the
+ * synthetic kinds return `true`.
+ */
+export declare function isClientEvent(value: unknown): value is ClientEvent;
+//# sourceMappingURL=clientEvents.d.ts.map

package/dist/qar/clientEvents.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientEvents.d.ts","sourceRoot":"","sources":["../../src/qar/clientEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,8EAA8E;AAC9E,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uDAAuD;IACvD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uFAAuF;IACvF,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,iFAAiF;AACjF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,8CAA8C;IAC9C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED,wEAAwE;AACxE,MAAM,WAAW,0BAA0B;IACzC,QAAQ,CAAC,IAAI,EAAE,6BAA6B,CAAC;IAC7C,2FAA2F;IAC3F,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,wDAAwD;IACxD,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC,mEAAmE;IACnE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,uEAAuE;IACvE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,0DAA0D;IAC1D,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,+DAA+D;IAC/D,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,kFAAkF;IAClF,QAAQ,CAAC,uBAAuB,CAAC,EAAE,MAAM,CAAC;CAC3C;AAED,MAAM,MAAM,WAAW,GACnB,uBAAuB,GACvB,sBAAsB,GACtB,0BAA0B,GAC1B,sBAAsB,CAAC;AAE3B,uEAAuE;AACvE,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC;AASlD;;;;;;;GAOG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAIlE"}

package/dist/qar/clientEvents.js

@@ -0,0 +1,36 @@
+/**
+ * SDK-internal lifecycle events surfaced on the canonical `TaskEvent` iterator
+ * and on `client.receive()`.
+ *
+ * These are NOT QAR envelope kinds — the `qar.client.*` namespace makes them
+ * unambiguously SDK-side so a stray server-side discriminant can never collide
+ * with one. They have no `message_id`, no `session_id`, no `payload` shape.
+ *
+ * The current set: `qar.client.reconnecting` / `qar.client.reconnected`
+ * / `qar.client.reconnect_failed` for transport-loss recovery, plus
+ * `qar.client.cancel_acked` synthesized from inbound `task.canceling`
+ * envelopes so consumers can render the "cancel acknowledged, awaiting
+ * terminal" intermediate state without expanding the `TaskEvent`
+ * switch. `kind` is the stable forward-compatible discriminator.
+ */
+const CLIENT_EVENT_KINDS = new Set([
+    'qar.client.reconnecting',
+    'qar.client.reconnected',
+    'qar.client.reconnect_failed',
+    'qar.client.cancel_acked',
+]);
+/**
+ * Type guard: `true` for `qar.client.*` synthetic events.
+ *
+ * Accepts `unknown` so JS callers (or callers feeding raw deserialized JSON)
+ * can drop arbitrary values in without crashing on `null` / `undefined` /
+ * primitives. Only objects with a string `kind` matching one of the
+ * synthetic kinds return `true`.
+ */
+export function isClientEvent(value) {
+    if (typeof value !== 'object' || value === null)
+        return false;
+    const kind = value.kind;
+    return typeof kind === 'string' && CLIENT_EVENT_KINDS.has(kind);
+}
+//# sourceMappingURL=clientEvents.js.map

package/dist/qar/clientEvents.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clientEvents.js","sourceRoot":"","sources":["../../src/qar/clientEvents.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AA0EH,MAAM,kBAAkB,GAAwB,IAAI,GAAG,CAAkB;IACvE,yBAAyB;IACzB,wBAAwB;IACxB,6BAA6B;IAC7B,yBAAyB;CAC1B,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC1C,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IAC9D,MAAM,IAAI,GAAI,KAAqC,CAAC,IAAI,CAAC;IACzD,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,kBAAkB,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAClE,CAAC"}

package/dist/qar/envelopes.d.ts

@@ -0,0 +1,227 @@
+/**
+ * QAR envelope discriminated union — public surface.
+ *
+ * Backed by the codegen output in `./generated/envelope.ts` (regenerated from
+ * `schemas/qar/envelope.json` via `npm run codegen:qar`). This file is the
+ * curated overlay: it re-exports the codegen variants under both their
+ * QAR-native names (`TaskStart`, `TaskContinue`, …) and the SDK-2.0
+ * `…Envelope` aliases, and it sharpens the codegen output where the wire
+ * is stricter than the schema can express:
+ *
+ *   - `kind` is required (Pydantic exports it with a default, which makes
+ *     json-schema-to-typescript emit it optional). On the wire it is always
+ *     present and acts as the discriminator.
+ *   - `envelope_version` is the literal `1` (same Pydantic-default reason).
+ *   - `message_id` / `session_id` / `parent_message_id` are branded UUID
+ *     strings (`MessageId` / `SessionId`) so callers cannot accidentally
+ *     swap them at API boundaries — a property the JSON Schema can't
+ *     express but the SDK relies on.
+ *
+ * The direction whitelists below stay hand-written: they're an SDK-side
+ * projection of QAR's `protocol/envelopes.py` taxonomy.
+ */
+import type { TaskStart, TaskContinue, TaskCancel, TaskResubscribe, TaskDelta, TaskDone, ToolRequest, ToolResponse, StateUpdate, AgentSpawn, BulletinPost, ArtifactAdd, FlowPause, FlowResume, ErrorEnv } from './generated/envelope.js';
+import type { MessageId, SessionId } from './ids.js';
+import type { TaskCancelingPayload, TaskForceResumePayload, TaskForceResumedPayload, TaskStartedPayload, TaskStartPayload, ToolRequestPayload, ToolResponsePayload } from './payloads.js';
+/** Envelope-version literal. QAR bumps this on any breaking schema change. */
+export type EnvelopeVersion = 1;
+/**
+ * Sharpens a codegen ONGOING envelope variant: marks `kind` +
+ * `envelope_version` required, brands the UUID id fields. Generic so we
+ * apply it once per variant without duplicating the field list.
+ *
+ * Corresponds to `_OngoingEnvelopeBase` — every kind EXCEPT
+ * `task.start` carries `session_id` on the wire. The companion
+ * {@link SharpenStart} is the `_StartEnvelopeBase` shape (no
+ * `session_id`); the SDK's start encoder strips the field at emit-time,
+ * but the public wire overlay must mirror the omission so raw senders
+ * via {@link QodoClient.send} can't compile an invalid `task.start`.
+ */
+type Sharpen<T extends {
+    kind?: string;
+}> = Omit<T, 'kind' | 'envelope_version' | 'message_id' | 'session_id' | 'parent_message_id'> & {
+    readonly kind: NonNullable<T['kind']>;
+    readonly envelope_version: EnvelopeVersion;
+    readonly message_id: MessageId;
+    readonly session_id: SessionId;
+    readonly parent_message_id?: MessageId | null;
+};
+/**
+ * Sharpens a `_StartEnvelopeBase` codegen variant — same as
+ * {@link Sharpen} but WITHOUT `session_id`. The `task.start` envelope
+ * does not carry `session_id` on the wire; the server derives it from
+ * `(tenant_id, payload.idempotency_key)` during the ingress
+ * bind-and-derive phase. QAR's Pydantic model has `extra="forbid"`, so
+ * any stray `session_id` on a `task.start` would fail server-side
+ * parsing.
+ */
+type SharpenStart<T extends {
+    kind?: string;
+}> = Omit<T, 'kind' | 'envelope_version' | 'message_id' | 'session_id' | 'parent_message_id'> & {
+    readonly kind: NonNullable<T['kind']>;
+    readonly envelope_version: EnvelopeVersion;
+    readonly message_id: MessageId;
+    readonly parent_message_id?: MessageId | null;
+};
+/**
+ * `task.start` envelope — `payload` is the discriminated union
+ * (`{ agent_id, ... } | { agent, ... } | { graph, ... }`) rather than
+ * the pre-amendment single-variant codegen shape. The generated
+ * `TaskStart.payload` still carries the original
+ * `{ agent_id, input, skill? }` shape; the `Omit<…, 'payload'> & { payload:
+ * TaskStartPayload }` swap masks it until QAR's schema export catches
+ * up.
+ *
+ * Built on {@link SharpenStart} (not {@link Sharpen}) so the type has
+ * NO `session_id` field — `task.start` is QAR's `_StartEnvelopeBase`,
+ * and the server-side `extra="forbid"` Pydantic config rejects a stray
+ * `session_id`. The SDK's encoder (`Connection.sendEnvelope` for
+ * `kind === 'task.start'`) strips the field at emit-time; the type
+ * narrowing here ensures raw senders via {@link QodoClient.send} can't
+ * compile an invalid envelope either.
+ */
+export type TaskStartEnvelope = Omit<SharpenStart<TaskStart>, 'payload'> & {
+    readonly payload: TaskStartPayload;
+};
+/**
+ * `task.started` envelope — admission-commit ack.
+ *
+ * Hand-rolled `EnvelopeBase + { kind, payload }` shape because the
+ * variant is not yet in the vendored schema bundle. Same pattern the
+ * parallel-batched tool envelopes use while their schema bump is in
+ * flight; when the schema is bumped and `npm run codegen:qar`
+ * regenerates `./generated/envelope.ts`, fold this back into a
+ * `Sharpen<>` over the codegen variant.
+ *
+ * Per the QAR wire `_OngoingEnvelopeBase.parent_message_id` narrowing
+ * for this kind: the field is **required and non-nullable** — it equals
+ * the originating `task.start.message_id` and the SDK uses it for
+ * correlation. The SDK's `parseEnvelope` does NOT enforce the
+ * narrowing (the codegen base allows nullable), but the routing logic
+ * in `TaskSubscription.consider` matches on `parent_message_id` so a
+ * spec-violating server emit with `parent_message_id = null` would fail
+ * to route — surfaces as an absent ack from the consumer's POV (the
+ * `sessionId` promise never resolves), not a silent miss.
+ */
+export interface TaskStartedEnvelope extends EnvelopeBase {
+    readonly kind: 'task.started';
+    readonly parent_message_id: MessageId;
+    readonly payload: TaskStartedPayload;
+}
+export type TaskContinueEnvelope = Sharpen<TaskContinue>;
+export type TaskCancelEnvelope = Sharpen<TaskCancel>;
+/**
+ * `task.canceling` envelope — cancel-ack surface.
+ *
+ * Carried as a hand-rolled `EnvelopeBase + { kind, payload }` shape
+ * because the variant is not yet in the vendored schema bundle. When
+ * the schema is bumped and `npm run codegen:qar` regenerates
+ * `./generated/envelope.ts`, fold this back into a `Sharpen<>` over the
+ * codegen variant.
+ */
+export interface TaskCancelingEnvelope extends EnvelopeBase {
+    readonly kind: 'task.canceling';
+    readonly payload: TaskCancelingPayload;
+}
+export type TaskResubscribeEnvelope = Sharpen<TaskResubscribe>;
+export type TaskDeltaEnvelope = Sharpen<TaskDelta>;
+export type TaskDoneEnvelope = Sharpen<TaskDone>;
+/**
+ * `task.forceResume` envelope — stuck-session recovery primitive (C→S).
+ * Hand-rolled because the variant is not yet in the vendored schema
+ * bundle; same pattern `task.started` uses.
+ *
+ * Built on {@link SharpenStart} (no `session_id` on the wire) because
+ * forceResume operates on the consumer's `idempotency_key` rather than
+ * an already-bound session UUID — the consumer is typically recovering
+ * a session whose UUID it has lost (process restart). QAR derives the
+ * session UUID server-side via the same `uuidv5(QAR_NS_V1, tenant_id +
+ * ":" + idempotency_key)` derivation as `task.start` admission.
+ */
+export interface TaskForceResumeEnvelope extends Omit<EnvelopeBase, 'session_id'> {
+    readonly kind: 'task.forceResume';
+    readonly payload: TaskForceResumePayload;
+}
+/**
+ * `task.force_resumed` envelope — ack for `task.forceResume` (S→C).
+ *
+ * Carries the derived `session_id` (so the SDK can pin the session for
+ * subsequent `task.continue` calls) plus the payload's `task_id` +
+ * `state`. Hand-rolled mirror of `task.started`.
+ */
+export interface TaskForceResumedEnvelope extends EnvelopeBase {
+    readonly kind: 'task.force_resumed';
+    readonly parent_message_id: MessageId;
+    readonly payload: TaskForceResumedPayload;
+}
+/**
+ * `tool.request` envelope — `payload` is the parallel-batched overlay
+ * (`calls: ToolCall[]`, required `node_name`) rather than the
+ * pre-amendment codegen shape. Until the schema is bumped, the
+ * generated `ToolRequest['payload']` is still the single-call form;
+ * the `Omit<…, 'payload'> & { payload: ToolRequestPayload }` swap masks
+ * it.
+ */
+export type ToolRequestEnvelope = Omit<Sharpen<ToolRequest>, 'payload'> & {
+    readonly payload: ToolRequestPayload;
+};
+/** `tool.response` envelope — `payload` is the parallel-batched overlay. */
+export type ToolResponseEnvelope = Omit<Sharpen<ToolResponse>, 'payload'> & {
+    readonly payload: ToolResponsePayload;
+};
+export type StateUpdateEnvelope = Sharpen<StateUpdate>;
+export type AgentSpawnEnvelope = Sharpen<AgentSpawn>;
+export type BulletinPostEnvelope = Sharpen<BulletinPost>;
+export type ArtifactAddEnvelope = Sharpen<ArtifactAdd>;
+export type FlowPauseEnvelope = Sharpen<FlowPause>;
+export type FlowResumeEnvelope = Sharpen<FlowResume>;
+export type ErrorEnvelope = Sharpen<ErrorEnv>;
+/**
+ * Common fields on every envelope. Derived from the shape `Sharpen` produces
+ * (intersection of required base fields). Hand-written declaration so the
+ * exported interface is grokable in API docs without chasing the helper.
+ */
+export interface EnvelopeBase {
+    readonly envelope_version: EnvelopeVersion;
+    readonly message_id: MessageId;
+    readonly parent_message_id?: MessageId | null;
+    readonly session_id: SessionId;
+    readonly trace_context: import('./generated/envelope.js').TraceContext;
+    readonly ts: string;
+}
+/**
+ * The 15-kind envelope discriminated union. Every QAR-side wire message lands here.
+ *
+ * Use `switch (env.kind)` to narrow; `kind` is the single source of truth (no
+ * payload-level discriminator, no two-level nesting).
+ */
+export type Envelope = TaskStartEnvelope | TaskStartedEnvelope | TaskContinueEnvelope | TaskCancelEnvelope | TaskCancelingEnvelope | TaskResubscribeEnvelope | TaskDeltaEnvelope | TaskDoneEnvelope | TaskForceResumeEnvelope | TaskForceResumedEnvelope | ToolRequestEnvelope | ToolResponseEnvelope | StateUpdateEnvelope | AgentSpawnEnvelope | BulletinPostEnvelope | ArtifactAddEnvelope | FlowPauseEnvelope | FlowResumeEnvelope | ErrorEnvelope;
+/** All envelope `kind` values, as a string-literal union. */
+export type EnvelopeKind = Envelope['kind'];
+/** Direction whitelists — kept in sync with QAR's `protocol/envelopes.py` taxonomy. */
+export declare const CLIENT_TO_SERVER_KINDS: readonly ["task.start", "task.continue", "task.cancel", "task.resubscribe", "task.forceResume", "tool.response"];
+export declare const SERVER_TO_CLIENT_KINDS: readonly ["task.started", "task.delta", "task.done", "task.canceling", "task.force_resumed", "tool.request", "agent.spawn", "bulletin.post", "flow.pause", "flow.resume", "error"];
+/**
+ * Kinds the wire allows in both directions. Mirrors QAR's
+ * `protocol/envelopes.BIDIRECTIONAL_KINDS = {"state.update", "artifact.add"}`.
+ *
+ * **`artifact.add`** is on the QAR-side bidirectional whitelist so a future
+ * SDK client-emitted artifact path (a tool handler attaching a file, a skill
+ * pushing a structured record) can land without a wire-contract change. The
+ * SDK currently does not emit `artifact.add` — `ArtifactsClient` is
+ * observer-only and the outbound-payload union (`OutboundPayload` in
+ * `connection.ts`) does not include `artifact.add`. Aligning the taxonomy
+ * here matches the cross-repo wire contract (per the 2026-05-13 retro) so
+ * the SDK never rejects an inbound `artifact.add` for direction reasons.
+ * Same precedent as `state.update`: bidirectional on the wire, observer-only
+ * on the public surface today.
+ *
+ * If you're auditing where SDK-side emission lands: ArtifactsClient.onArtifact
+ * is the read path; emit lives in a future ticket.
+ */
+export declare const BIDIRECTIONAL_KINDS: readonly ["state.update", "artifact.add"];
+export type ClientToServerKind = (typeof CLIENT_TO_SERVER_KINDS)[number];
+export type ServerToClientKind = (typeof SERVER_TO_CLIENT_KINDS)[number];
+export type BidirectionalKind = (typeof BIDIRECTIONAL_KINDS)[number];
+export {};
+//# sourceMappingURL=envelopes.d.ts.map

package/dist/qar/envelopes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"envelopes.d.ts","sourceRoot":"","sources":["../../src/qar/envelopes.ts"],"names":[],"mappings":"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"}