@namzu/sdk 62.12.0 → 62.13.0

package/src/types/connector/mcp.ts

@@ -416,6 +416,12 @@ export interface MCPClientCapabilities {
 	 * only. The client sets it, a caller passing it by hand gets no handler.
 	 */
 	elicitation?: Record<string, never>
+	/**
+	 * Extensions beyond the core protocol, by identifier (2026-07-28). The
+	 * client adds `io.modelcontextprotocol/tasks` itself when the server
+	 * advertises it and {@link MCPClientConfig.tasks} is not `false`.
+	 */
+	extensions?: Record<string, Record<string, unknown>>
 	experimental?: Record<string, unknown>
 }
 
@@ -424,6 +430,8 @@ export interface MCPServerCapabilities {
 	resources?: { subscribe?: boolean; listChanged?: boolean }
 	prompts?: { listChanged?: boolean }
 	logging?: Record<string, never>
+	/** Extensions the server offers, by identifier (2026-07-28 `server/discover`). */
+	extensions?: Record<string, Record<string, unknown>>
 	experimental?: Record<string, unknown>
 }
 
@@ -500,6 +508,16 @@ export interface MCPClientConfig {
 	transportFactory?: () => MCPTransport
 	capabilities?: MCPClientCapabilities
 	clientInfo?: { name: string; version: string }
+	/**
+	 * Take part in the tasks extension (2026-07-28). Default `true`.
+	 *
+	 * When the server advertises `io.modelcontextprotocol/tasks`, the client
+	 * declares it on each request, and a `tools/call` the server turns into a
+	 * task is waited on until it ends: `callTool()` resolves with the task's
+	 * result exactly as if the server had answered at once. `false` declares
+	 * nothing, so a server never returns a task to this client.
+	 */
+	tasks?: boolean
 	/**
 	 * Answer a server's `elicitation/create` (form mode) by asking the person.
 	 *

package/src/types/goal/index.ts

@@ -3,6 +3,13 @@ import type { GoalId, SessionId, TenantId } from '../ids/index.js'
 /** Durable lifecycle of one same-session completion goal. */
 export type GoalPhase = 'active' | 'paused' | 'blocked' | 'complete'
 
+/**
+ * Who says a goal is done. `model`: the model's own report ends the goal, as it
+ * always has. `record`: the kernel reads the record of the work done for the
+ * goal first, and the goal ends only as that record allows.
+ */
+export type GoalConfirmedBy = 'model' | 'record'
+
 /** Machine-routable and human-readable reason that a goal stopped. */
 export interface GoalBlockReason {
 	/** Stable lower-kebab-case policy code. */
@@ -33,6 +40,12 @@ export interface SessionGoal extends GoalRef {
 	readonly maxGoalRounds: number
 	/** Durable admissions, not a claim that the provider began or completed. */
 	readonly roundsAdmitted: number
+	/**
+	 * What this goal was created to be confirmed by. Absent means the host's own
+	 * setting decides, which is the case for every goal created before this
+	 * field existed.
+	 */
+	readonly confirmedBy?: GoalConfirmedBy
 	/** Present exactly while {@link phase} is `blocked`. */
 	readonly blockedReason?: GoalBlockReason
 	readonly createdAt: number

package/src/types/session/config.ts

@@ -106,6 +106,14 @@ export interface TurnConfig {
 	 * Off when absent, so an embedding host sees no change.
 	 */
 	completionAudit?: boolean
+	/**
+	 * Let the model hand the task back to a person (`hand_back_task`) instead of
+	 * forcing a result it cannot honestly reach. On: the tool is offered, a short
+	 * paragraph of guidance joins the static system prompt, and a call to the tool
+	 * ends the turn with nothing else run (`Turn.handedBack`). Off or absent: the
+	 * tool is absent and the prompt is byte for byte what it was.
+	 */
+	handBack?: boolean
 	/**
 	 * How many times in a row `turn_end` / `subagent_stop` hooks may refuse to
 	 * let the turn end (answer `skip`) before the turn stops honouring them. At

package/src/types/session/hand-back.ts

@@ -0,0 +1,31 @@
+/**
+ * A turn the model handed back to a person (`docs/sdk/hand-back.md`).
+ *
+ * The model calls `hand_back_task` when the task cannot be finished as
+ * specified and the honest thing is to stop and say so. The turn ends there:
+ * no further model call, nothing else runs. The fact is kept beside the
+ * turn's outcome verdict, not inside it: a turn can have changed files and
+ * still have been handed back.
+ */
+
+/** Why the model stopped; a small closed set so a script can branch on it. */
+export type HandBackKind =
+	/** The request conflicts with itself, or with the checks that decide whether it is done. */
+	| 'conflict'
+	/** Something needed is missing or not allowed: an input, a file, a credential, a permission. */
+	| 'missing'
+	/** A decision is needed that belongs to a person. */
+	| 'decision'
+
+export const HAND_BACK_KINDS: readonly HandBackKind[] = ['conflict', 'missing', 'decision']
+
+/** What the model said when it handed the task back. The words are the model's. */
+export interface HandBack {
+	readonly kind: HandBackKind
+	/** What blocks it. */
+	readonly blocker: string
+	/** What it tried. */
+	readonly tried: string
+	/** What a person has to decide or provide. */
+	readonly needed: string
+}

package/src/types/session/outcome.ts

@@ -74,6 +74,35 @@ export interface TurnOutcome {
 	readonly checksTotal?: number
 }
 
+/** What a plain claim in an answer was about. */
+export type AnswerClaimKind = 'tests' | 'build' | 'lint' | 'typecheck' | 'checks'
+
+/** What the turn's record held that the claim did not match. */
+export type AnswerClaimRecord =
+	/** A check's latest run failed. */
+	| 'check-failed'
+	/** Files changed and no check ran. */
+	| 'unchecked'
+	/** Files changed and no check established a pass, or its result could not be read. */
+	| 'unreadable'
+
+/**
+ * An answer said a check passed and the same turn's record says otherwise.
+ *
+ * Recorded, not acted on: the model is not told and nothing blocks. See
+ * `compareAnswerToOutcome`.
+ */
+export interface AnswerClaimMismatch {
+	readonly claim: AnswerClaimKind
+	/** The claim in the kernel's words, for example `the tests pass`. */
+	readonly said: string
+	/** The clause of the answer it was found in, whitespace folded and clipped. */
+	readonly quote: string
+	readonly record: AnswerClaimRecord
+	/** What the record holds, in the kernel's words, for example `pnpm test failed`. */
+	readonly recordSays: string
+}
+
 /** Host hooks for the turn's outcome record. */
 export interface TurnOutcomeConfig {
 	/**
@@ -88,6 +117,19 @@ export interface TurnOutcomeConfig {
 	readonly isCheck?: (command: string) => boolean
 	/** Deadline per detector call. A detector that is late is `null`. Default 3000. */
 	readonly detectTimeoutMs?: number
+	/**
+	 * Asked when the model has finished its answer with no tool call left and
+	 * the turn would end. `read` gives the turn's record as it stands, with the
+	 * workspace compared once; it is not computed unless called. A returned
+	 * sentence goes to the model as a runtime note and the turn goes on; nothing
+	 * returned lets the turn end. A turn that is being stopped by a limit, a
+	 * cancellation or a forced final answer is not asked, so a limit always wins
+	 * over this hook. At most 16 notes are honoured in one turn. A hook that
+	 * throws is read as nothing returned.
+	 */
+	readonly beforeEnd?: (
+		read: () => Promise<TurnOutcome | undefined>,
+	) => string | undefined | Promise<string | undefined>
 }
 
 /** Bounds on a recorded outcome. */

package/src/types/session/turn.ts

@@ -11,7 +11,8 @@ import type {
 import type { Message } from '../message/index.js'
 import type { ProviderErrorInfo } from '../provider/index.js'
 import type { TurnConfig } from './config.js'
-import type { TurnOutcome } from './outcome.js'
+import type { HandBack } from './hand-back.js'
+import type { AnswerClaimMismatch, TurnOutcome } from './outcome.js'
 import type { StepResult } from './step.js'
 import type { StopReason } from './stop-reason.js'
 
@@ -166,6 +167,21 @@ export interface LiveTurnSettlement extends TurnSettlement {
 	 * did not keep the record.
 	 */
 	readonly outcome?: TurnOutcome
+	/**
+	 * A plain claim in the answer that this turn's outcome record contradicts.
+	 * Shadow only: the model is not told and nothing blocks. In memory only,
+	 * like {@link LiveTurnSettlement.outcome}; the session log does not keep it.
+	 * Absent when the answer made no such claim, which is the usual case.
+	 */
+	readonly claimMismatch?: AnswerClaimMismatch
+	/**
+	 * The model handed the task back to a person (`hand_back_task`) and the turn
+	 * ended there. A fact beside {@link LiveTurnSettlement.outcome}, not a field of
+	 * it: a turn can have changed files and been handed back. In memory only; the
+	 * session log keeps no record of it, since the call and its words are already in
+	 * the saved conversation and a reopened one reads them from there.
+	 */
+	readonly handedBack?: HandBack
 }
 
 /** Metadata of one turn: who ran it, with what, and where it sits in the session tree. */
@@ -235,6 +251,8 @@ export interface Turn {
 	abandonedJobIds?: readonly string[]
 	/** What the turn changed and what checked it; see {@link LiveTurnSettlement.outcome}. */
 	outcome?: TurnOutcome
+	/** Set when the model handed the task back; see {@link LiveTurnSettlement.handedBack}. */
+	handedBack?: HandBack
 	/** Present on a child session's turn. */
 	parentSessionId?: SessionId
 	/** Present on a child session's turn. */