@namzu/sdk 60.2.1 → 61.1.0

package/src/peers/record.ts

@@ -23,6 +23,24 @@ import {
 /** Bumped only if the on-disk record shape changes incompatibly. */
 export const PEER_RECORD_VERSION = 1
 
+/**
+ * One exchange this terminal took part in: who with (their short reference), which way
+ * it went, and when. Never the text, never a size: a host that draws who is talking to
+ * whom needs nothing more, and a record is readable by every process of the user.
+ */
+export const PeerExchangeSchema = z
+	.object({
+		with: PeerRefSchema,
+		dir: z.enum(['in', 'out']),
+		at: z.number().int().nonnegative(),
+	})
+	.strict()
+
+export type PeerExchange = z.infer<typeof PeerExchangeSchema>
+
+/** The most recent exchanges a record keeps, newest last. A burst between two reads of a record is not lost for four or fewer. */
+export const PEER_TRAIL_MAX = 4
+
 export const PeerRecordSchema = z
 	.object({
 		v: z.literal(PEER_RECORD_VERSION),
@@ -53,6 +71,8 @@ export const PeerRecordSchema = z
 		limited: z.boolean().optional(),
 		/** When the allowance is expected back (epoch ms); absent when the provider did not say. */
 		limitedUntil: z.number().int().positive().optional(),
+		/** The latest exchanges with other terminals, newest last; absent for a terminal that has had none or does not report them. */
+		trail: z.array(PeerExchangeSchema).max(PEER_TRAIL_MAX).optional(),
 	})
 	.strict()
 

package/src/public-runtime.ts

@@ -1865,6 +1865,7 @@ export {
 	OUTSTANDING_EXPIRY_MS,
 	PEER_PROTOCOL_VERSION,
 	PEER_RECORD_VERSION,
+	PEER_TRAIL_MAX,
 	PeerAddressError,
 	PeerClient,
 	PeerClientError,

package/src/public-types.ts

@@ -800,7 +800,7 @@ export type {
 	PeerRuntimeDir,
 	ResolvePeerRuntimeDirOptions,
 } from './peers/dir.js'
-export type { PeerRecord } from './peers/record.js'
+export type { PeerExchange, PeerRecord } from './peers/record.js'
 export type { AccountBoundRecord } from './types/session/records.js'
 export type {
 	Account,

package/src/registry/tool/dialect.ts

@@ -7,9 +7,9 @@
  * at the boundary where it knows which wire it is about to talk to.
  *
  * This exists because that layering was missing and it cost a production
- * outage. `renderToolSchema` emits draft-07 (zod-to-json-schema's
- * `jsonSchema7` target), every driver forwarded it verbatim, and one of the
- * wires namzu speaks requires draft 2020-12. Measured against that live
+ * outage. `renderToolSchema` emits draft-07 (Zod's `draft-7` target), every
+ * driver forwarded it verbatim, and one of the wires namzu speaks requires
+ * draft 2020-12. Measured against that live
  * endpoint:
  *
  * | tool schema                    | result                                  |
@@ -27,7 +27,7 @@
  * lives here.
  *
  * Only the conversions namzu can actually emit are implemented. The renderer
- * runs with `$refStrategy: 'none'`, so there are no `$ref`/`definitions` to
+ * inlines every reused schema, so there are no `$ref`/`definitions` to
  * rewrite; a construct that cannot appear is not worth code that cannot be
  * tested.
  */

package/src/registry/tool/json-schema.ts

@@ -0,0 +1,76 @@
+import { z } from 'zod'
+
+/**
+ * The one place a Zod schema becomes a JSON Schema document.
+ *
+ * Zod renders its own JSON Schema (`z.toJSONSchema`), and it is the only
+ * converter that reads a Zod 4 schema: the standalone converters walk the
+ * Zod 3 internals and return an empty document (`{ "$schema": ... }`) for a
+ * Zod 4 tree, which would put every tool on the wire as "takes anything".
+ *
+ * The raw output differs from what a model has always been shown in three
+ * ways that carry no information, and each would change the bytes of the
+ * tools block — which sits at the head of the prompt-cache prefix — for
+ * nothing. They are normalised here, once, so the wire stays what it was:
+ *
+ * 1. **A plain object is closed.** An object that neither allows extra keys
+ *    nor declares a catch-all renders `additionalProperties: false`. Zod
+ *    parses such an object by dropping unknown keys, so "closed" is the
+ *    contract the model should be told. Rendering in the input direction
+ *    (needed so a field with a default stays optional) omits the keyword for
+ *    these; it is put back. An open object (`looseObject`, `.passthrough()`)
+ *    renders `true`, not the equivalent empty schema.
+ *
+ * 2. **An integer is not bounded by the safe-integer range.** `.int()` adds
+ *    `minimum`/`maximum` at +/- 2^53 - 1 to every integer. They restate what
+ *    "integer" already means to a model and are removed. A bound the author
+ *    wrote differently is kept.
+ *
+ * 3. **A named string format is not also a pattern.** A format such as
+ *    `uuid` or `date-time` is rendered together with the very long regular
+ *    expression that implements it. The format says it; the pattern is
+ *    noise, and the open-API-3.0-shaped wires do not read it anyway.
+ */
+export type JsonSchemaTarget = 'draft-7' | 'openapi-3.0'
+
+const MAX_SAFE = Number.MAX_SAFE_INTEGER
+
+export function zodToJsonSchema(
+	schema: z.ZodType,
+	target: JsonSchemaTarget = 'draft-7',
+): Record<string, unknown> {
+	// A Zod 3 schema has `safeParse` and `_def`, so it passes every shape check
+	// a registration makes, and then fails here with a `TypeError` about an
+	// internal nobody wrote. Say what is actually wrong.
+	if (typeof (schema as { _zod?: unknown })._zod !== 'object') {
+		throw new TypeError(
+			'This input schema was not built with Zod 4. The kernel renders and validates tool input with Zod 4 (`zod` 4 or newer); a schema from Zod 3 cannot be described to a model.',
+		)
+	}
+	return z.toJSONSchema(schema, {
+		target,
+		// What a caller may send, so a field with a default stays optional.
+		io: 'input',
+		// A transform, a date or a bigint has no JSON form; it renders as
+		// "anything" rather than failing the whole tool.
+		unrepresentable: 'any',
+		override: ({ zodSchema, jsonSchema }) => {
+			const node = jsonSchema as Record<string, unknown>
+			if (zodSchema._zod.def.type === 'object') {
+				if (node.additionalProperties === undefined) node.additionalProperties = false
+				else if (isEmptyObject(node.additionalProperties)) node.additionalProperties = true
+			}
+			if (node.type === 'integer') {
+				if (node.minimum === -MAX_SAFE) delete node.minimum
+				if (node.maximum === MAX_SAFE) delete node.maximum
+			}
+			if (typeof node.format === 'string' && typeof node.pattern === 'string') {
+				delete node.pattern
+			}
+		},
+	}) as Record<string, unknown>
+}
+
+function isEmptyObject(value: unknown): boolean {
+	return typeof value === 'object' && value !== null && Object.keys(value).length === 0
+}

package/src/registry/tool/portable.ts

@@ -67,8 +67,8 @@ const OUTSIDE_THE_INTERSECTION: ReadonlyMap<string, string> = new Map([
 	// the function-declaration schema on one of these wires is an OpenAPI 3.0
 	// subset that has never documented it.
 	['prefixItems', NO_TUPLES],
-	// A rendered tool schema has to stand alone. The renderer already runs with
-	// `$refStrategy: 'none'`, and the MCP bridge inlines refs before handing a
+	// A rendered tool schema has to stand alone. The renderer already inlines
+	// every reused schema, and the MCP bridge inlines refs before handing a
 	// schema out, because a wire that does not resolve them sees an empty
 	// constraint or refuses the document.
 	['$ref', 'inline the referenced schema; a tool schema has to stand alone'],

package/src/registry/tool/schema.ts

@@ -1,5 +1,5 @@
 import type { z } from 'zod'
-import { zodToJsonSchema } from 'zod-to-json-schema'
+import { zodToJsonSchema } from './json-schema.js'
 import { toPortableToolSchema } from './portable.js'
 
 /**
@@ -8,7 +8,7 @@ import { toPortableToolSchema } from './portable.js'
  *
  * Two things were wrong with converting at each call site:
  *
- * 1. **`$schema` leaked into every request.** `zodToJsonSchema` stamps
+ * 1. **`$schema` leaked into every request.** the converter stamps
  *    `"$schema": "http://json-schema.org/draft-07/schema#"` on the root.
  *    No provider reads it, and it rides in the tools block — which renders
  *    at position 0, inside the cached prefix — once per tool, per request,
@@ -40,10 +40,7 @@ export function renderToolSchema(schema: z.ZodType): Record<string, unknown> {
 	const cached = CACHE.get(schema)
 	if (cached) return cached
 
-	const json = zodToJsonSchema(schema, {
-		target: 'jsonSchema7',
-		$refStrategy: 'none',
-	}) as Record<string, unknown>
+	const json = zodToJsonSchema(schema, 'draft-7')
 
 	const normalized = deepFreeze(normalizeToolSchema(json))
 	CACHE.set(schema, normalized)

package/src/tools/coordinator/index.ts

@@ -320,10 +320,8 @@ const approvePlanModelInputSchema: Record<string, unknown> = {
 function delegateSchema(agentIds: readonly string[]): z.ZodType<string> {
 	if (agentIds.length === 0) {
 		return z.never({
-			errorMap: () => ({
-				message:
-					'This turn has no delegates configured, so it cannot launch a task. That is the configured state, not a missing argument.',
-			}),
+			error: () =>
+				'This turn has no delegates configured, so it cannot launch a task. That is the configured state, not a missing argument.',
 		}) as unknown as z.ZodType<string>
 	}
 	return z.enum(agentIds as [string, ...string[]])

package/src/tools/defineTool.ts

@@ -129,7 +129,7 @@ export function defineTool<S extends z.ZodType>(
 	return {
 		name: options.name,
 		description: options.description,
-		inputSchema: options.inputSchema,
+		inputSchema: options.inputSchema as z.ZodType<TInput, unknown>,
 		modelInputSchema: options.modelInputSchema,
 		enforceModelInput: options.enforceModelInput,
 		validationErrorHint: options.validationErrorHint,

package/src/types/connector/core.ts

@@ -27,13 +27,13 @@ export type ConnectorCategory =
 export interface ConnectorMethod<TInput = unknown, TOutput = unknown> {
 	name: string
 	description: string
-	inputSchema: z.ZodType<TInput, z.ZodTypeDef, unknown>
+	inputSchema: z.ZodType<TInput, unknown>
 	/**
 	 * Canonical output contract for this method. ConnectorManager validates a
 	 * successful implementation result before publishing it and exposes the
 	 * rendered schema to tool and MCP consumers.
 	 */
-	outputSchema?: z.ZodType<TOutput, z.ZodTypeDef, unknown>
+	outputSchema?: z.ZodType<TOutput, unknown>
 }
 
 /**

package/src/types/connector/definition.ts

@@ -24,7 +24,7 @@ export interface ConnectorDefinition<TConfig = unknown> {
 	 * Omit only when a custom connector intentionally accepts every scheme.
 	 */
 	supportedAuth?: readonly AuthType[]
-	configSchema: z.ZodType<TConfig, z.ZodTypeDef, unknown>
+	configSchema: z.ZodType<TConfig, unknown>
 	methods: ConnectorMethod[]
 	/**
 	 * Declared, not implemented — see {@link ConnectorTrigger}.

package/src/types/plugin/index.ts

@@ -560,7 +560,7 @@ export const PluginMCPServerConfigSchema = z
 		name: z.string().min(1),
 		command: z.string().min(1),
 		args: z.array(z.string()).optional(),
-		env: z.record(z.string()).optional(),
+		env: z.record(z.string(), z.string()).optional(),
 		connectTimeoutMs: z.number().int().positive().max(3_600_000).optional(),
 	})
 	.strict()

package/src/types/session/checkpoint.ts

@@ -65,7 +65,7 @@ const count = z.number().int().nonnegative().safe()
 const sha256 = z.string().regex(/^[a-f0-9]{64}$/)
 const iso = z.string().datetime({ offset: false })
 /** Annotated with the id's own alias, so declarations name it rather than expanding its brand. */
-function id<T extends string>(kind: EntityIdKind): z.ZodType<T, z.ZodTypeDef, unknown> {
+function id<T extends string>(kind: EntityIdKind): z.ZodType<T, unknown> {
 	return z.custom<T>((value) => isEntityId(value, kind), {
 		message: `expected a ${kind} id (UUID)`,
 	})

package/src/types/session/records.ts

@@ -49,7 +49,7 @@ const isoUtc = z.string().datetime({ offset: false })
 const text = z.string()
 
 /** Annotated with the id's own alias, so declarations name `SessionId` rather than expanding its brand. */
-function idSchema<T extends string>(kind: EntityIdKind): z.ZodType<T, z.ZodTypeDef, unknown> {
+function idSchema<T extends string>(kind: EntityIdKind): z.ZodType<T, unknown> {
 	return z.custom<T>((value) => isEntityId(value, kind), {
 		message: `expected a ${kind} id (UUID)`,
 	})
@@ -199,7 +199,7 @@ const platformError = z
 	.object({
 		code: text,
 		message: text,
-		details: z.record(z.unknown()).optional(),
+		details: z.record(z.string(), z.unknown()).optional(),
 		retryable: z.boolean(),
 	})
 	.strict()
@@ -219,7 +219,7 @@ const toolHandoff = z
 	.object({
 		kind: z.literal('human-required'),
 		reason: text,
-		detail: z.record(text).optional(),
+		detail: z.record(z.string(), text).optional(),
 	})
 	.strict()
 
@@ -799,11 +799,7 @@ const RECORD_OPTIONS = [
 	...Object.values(SPECIFIED_EVENT_SCHEMAS),
 	...Object.values(RECORD_ONLY_SCHEMAS),
 	OtherEventRecordSchema,
-] as unknown as [
-	z.ZodDiscriminatedUnionOption<'type'>,
-	z.ZodDiscriminatedUnionOption<'type'>,
-	...z.ZodDiscriminatedUnionOption<'type'>[],
-]
+] as unknown as [z.ZodObject, z.ZodObject, ...z.ZodObject[]]
 
 /**
  * A record of a type this reader does not know, written by a newer writer

package/src/types/tool/index.ts

@@ -1024,7 +1024,7 @@ export type ShellDialect = 'bash' | 'sh' | 'cmd'
 export interface ToolDefinition<TInput = unknown> extends ToolPresentation<TInput> {
 	name: string
 	description: string
-	inputSchema: z.ZodType<TInput, z.ZodTypeDef, unknown>
+	inputSchema: z.ZodType<TInput, unknown>
 	/**
 	 * Optional canonical JSON Schema shown to models instead of the runtime
 	 * Zod schema. Use this when runtime compatibility accepts aliases or