@jini-ai/daemon 0.6.8 → 0.6.10

package/dist/http/delegated-tools.js

@@ -27,11 +27,9 @@
  */
 import { randomUUID } from 'node:crypto';
 import { createApiError } from '@jini-ai/protocol';
-import { ToolInputError } from '@jini-ai/core';
+import { batchOutcomeFor, ToolInputError } from '@jini-ai/core';
 import { createDelegatedToolBridge } from '../index.js';
-import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
-import { validationError } from '@jini-ai/http-kit';
-import { err, ok } from '@jini-ai/http-kit';
+import { defineJsonRoute, err, mountJsonRoute, ok, validationError } from '@jini-ai/http-kit';
 import * as readOnlyTools from '../core/read-only-tools.js';
 /** Route preflight shares the same registration decision as nested dispatch. */
 function checkReadOnlyConstraint(deps, input) {
@@ -68,20 +66,14 @@ function describeSafely(deps, context) {
         return undefined;
     }
 }
-function reportInternalError(deps, source, error, runId, toolId, status) {
+function reportInternalError(deps, report) {
     const correlationId = randomUUID();
-    const context = {
-        source,
-        runId,
-        toolId,
-        correlationId,
-        error,
-        ...(status === undefined ? {} : { status }),
-    };
+    // Every caller either omits `status` or sets it, so spreading keeps "absent" absent.
+    const context = { ...report, correlationId };
     const sink = deps.onInternalError ?? defaultInternalErrorSink;
     sink(context);
     const message = describeSafely(deps, context) ?? 'an internal error occurred';
-    return createApiError({ code: 'INTERNAL_ERROR', message: message }, { requestId: correlationId });
+    return createApiError({ code: 'INTERNAL_ERROR', message }, { requestId: correlationId });
 }
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
@@ -118,7 +110,8 @@ function parseDelegatedToolExecute(input) {
 /**
  * Maps a settled `ToolExecutionResult` to the wire `Result` — the same status mapping
  * `db-ops.ts`'s `toolResultToApiResult` establishes for this identical `ToolExecutionResult`
- * union, kept consistent here rather than reinvented: `completed` → `200 {result}`,
+ * union: `completed` → `200 {result}`; a batch with failed items carries
+ * `partial_failure` or `error` plus its per-item output and isError. Other states map as follows:
  * `denied`/`confirmation-denied` → `403 TOOL_OPERATION_DENIED`, `timed-out`/`cancelled` → a
  * SEC-005-redacted `500 INTERNAL_ERROR` (the real status/error goes to `onInternalError`, never the
  * wire — unless the host supplies `deps.describeInternalError`, whose text then replaces the generic
@@ -135,26 +128,33 @@ function parseDelegatedToolExecute(input) {
  * vouches for this exact result via `deps.isModelSafeToolFailure` (it has already redacted the text
  * itself), in which case it is a `422 TOOL_EXECUTION_FAILED` carrying the host's text verbatim.
  */
-function toolExecutionResultToApiResult(deps, runId, toolId, result) {
+function toolExecutionResultToApiResult(deps, { runId, toolId, result }) {
     switch (result.status) {
-        case 'completed':
-            return ok({ value: { result } });
+        case 'completed': {
+            const outcome = batchOutcomeFor({ output: result.output });
+            return ok({ value: { result: outcome === undefined || outcome === 'completed' ? result
+                        : { ...result, status: outcome, outcome, isError: true } } });
+        }
         case 'denied':
             return err({ error: createApiError({ code: 'TOOL_OPERATION_DENIED', message: 'this operation was denied by policy' }) });
         case 'confirmation-denied':
             return err({ error: createApiError({ code: 'TOOL_OPERATION_DENIED', message: 'this operation was denied during confirmation' }) });
         case 'timed-out':
         case 'cancelled':
-            return err({ error: reportInternalError(deps, 'delegated-tool-execute', result.status, runId, toolId, result.status) });
+            return err({ error: reportInternalError(deps, { source: 'delegated-tool-execute', error: result.status, runId, toolId, status: result.status }) });
         case 'failed':
-            if (result.errorKind === 'validation') {
-                return err({ error: createApiError({ code: 'BAD_REQUEST', message: result.error ?? 'invalid tool input' }) });
-            }
-            if (result.error && deps.isModelSafeToolFailure?.({ result }) === true) {
-                return err({ error: createApiError({ code: 'TOOL_EXECUTION_FAILED', message: result.error }) });
-            }
-            return err({ error: reportInternalError(deps, 'delegated-tool-execute', result.error ?? result.status, runId, toolId, 'failed') });
+            return err({ error: failedResultToApiError(deps, { runId, toolId, result }) });
+    }
+}
+/** The `failed` arm of {@link toolExecutionResultToApiResult} — see its doc for the three-way split. */
+function failedResultToApiError(deps, { runId, toolId, result }) {
+    if (result.errorKind === 'validation') {
+        return createApiError({ code: 'BAD_REQUEST', message: result.error ?? 'invalid tool input' });
+    }
+    if (result.error && deps.isModelSafeToolFailure?.({ result }) === true) {
+        return createApiError({ code: 'TOOL_EXECUTION_FAILED', message: result.error });
     }
+    return reportInternalError(deps, { source: 'delegated-tool-execute', error: result.error ?? result.status, runId, toolId, status: 'failed' });
 }
 /**
  * `POST /api/delegated-tool-calls` — executes one delegated tool call against an already-started
@@ -183,7 +183,7 @@ export const delegatedToolExecuteRoute = defineJsonRoute({
             principal = await deps.resolvePrincipal({ request: input });
         }
         catch (error) {
-            return err({ error: reportInternalError(deps, 'resolve-principal', error, input.runId, input.toolId) });
+            return err({ error: reportInternalError(deps, { source: 'resolve-principal', error, runId: input.runId, toolId: input.toolId }) });
         }
         // Attenuates the resolved principal itself for a `requireReadOnly` call, so the constraint
         // survives past this route: a consumer's own `ToolExecutor` composition may dispatch a tool id
@@ -203,7 +203,7 @@ export const delegatedToolExecuteRoute = defineJsonRoute({
         const toolExecutor = input.requireReadOnly === true
             ? readOnlyTools.withReadOnlyToolConstraint({ inner: deps.toolExecutor, registry: deps.toolRegistry, messages: readOnlyTools.defaultDaemonMessages.readOnly, idGenerator: { newId: randomUUID } })
             : deps.toolExecutor;
-        const bridge = createDelegatedToolBridge({ lifecycle: deps.lifecycle, toolExecutor });
+        const bridge = createDelegatedToolBridge({ lifecycle: deps.lifecycle, toolExecutor }, deps);
         try {
             // `signal` carries the caller's HTTP connection dropping — see `mountJsonRoute`
             // (`adapter.ts`). The bridge already combines it with the run's own cancellation
@@ -217,13 +217,13 @@ export const delegatedToolExecuteRoute = defineJsonRoute({
                 input: input.input,
                 ...(signal !== undefined ? { signal } : {}),
             });
-            return toolExecutionResultToApiResult(deps, input.runId, input.toolId, result);
+            return toolExecutionResultToApiResult(deps, { runId: input.runId, toolId: input.toolId, result });
         }
         catch (error) {
             if (error instanceof ToolInputError) {
                 return err({ error: createApiError({ code: 'BAD_REQUEST', message: error.message }) });
             }
-            return err({ error: reportInternalError(deps, 'delegated-tool-execute', error, input.runId, input.toolId) });
+            return err({ error: reportInternalError(deps, { source: 'delegated-tool-execute', error, runId: input.runId, toolId: input.toolId }) });
         }
     }
 }, { requireSameOrigin: true });

package/dist/http/host-tools.d.ts

@@ -102,6 +102,7 @@ type ResolvedEntry = {
 } | {
     readonly available: false;
 };
+/** Resolves how to launch `entry`: its CLI shim first, then (darwin only) its app bundle, else unavailable. */
 export declare function resolveEntry({ entry }: {
     readonly entry: CatalogueEntry;
 }, { probeEnv }?: {

package/dist/http/host-tools.js

@@ -24,7 +24,8 @@ import { createApiError } from '@jini-ai/protocol';
 import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
 import { validationError } from '@jini-ai/http-kit';
 import { err, ok } from '@jini-ai/http-kit';
-import { denyAllWorkspaceRoots, resolveWorkspaceRoot, WorkspaceRootDeniedError } from './workspace-root.js';
+import { denyAllWorkspaceRoots } from './workspace-root.js';
+import { isRecord, readOptionalNonEmptyString, resolveResourceRoot, withoutUndefined } from './resource-request.js';
 const MAC_OPEN_COMMAND = '/usr/bin/open';
 /** The cross-platform-staple + macOS-bundle editor/tool catalogue, unchanged from the origin. */
 export const CATALOGUE = [
@@ -148,33 +149,38 @@ export async function probeMacBundle({ name, probeEnv }, _optional = {}) {
     }
     return null;
 }
+/** The CLI-shim half of {@link resolveEntry}: `null` when the entry has no `command` or it is not found. */
+async function resolveViaCommand({ entry, probeEnv }) {
+    if (!entry.command)
+        return null;
+    const resolved = await probeCommandOnPath({ command: entry.command, probeEnv });
+    if (!resolved)
+        return null;
+    const commandArgs = entry.commandArgs ?? (({ workingDir }) => [workingDir]);
+    return { available: true, resolvedPath: resolved, launch: { command: resolved, argsForDir: ({ workingDir }) => commandArgs({ workingDir }) } };
+}
+/**
+ * The macOS app-bundle half of {@link resolveEntry} (launched via `open -a`): `null` without a
+ * `macOpenBundle` or when no bundle is found. Off darwin it is `null` too: {@link probeMacBundle}
+ * itself returns `null` before any filesystem access on every non-darwin platform, so it is the
+ * single darwin gate (this function used to repeat that check).
+ */
+async function resolveViaMacBundle({ entry, probeEnv }) {
+    if (!entry.macOpenBundle)
+        return null;
+    const bundle = await probeMacBundle({ name: entry.macOpenBundle, probeEnv });
+    if (!bundle)
+        return null;
+    const macOpenArgs = entry.macOpenArgs ?? (({ bundleName, workingDir }) => ['-a', bundleName, workingDir]);
+    return {
+        available: true,
+        resolvedPath: bundle.path,
+        launch: { command: await resolveMacOpenCommand(probeEnv), argsForDir: ({ workingDir }) => macOpenArgs({ bundleName: bundle.name, workingDir }) },
+    };
+}
+/** Resolves how to launch `entry`: its CLI shim first, then (darwin only) its app bundle, else unavailable. */
 export async function resolveEntry({ entry }, { probeEnv = defaultProbeEnv({}) } = {}) {
-    if (entry.command) {
-        const resolved = await probeCommandOnPath({ command: entry.command, probeEnv });
-        if (resolved) {
-            return {
-                available: true,
-                resolvedPath: resolved,
-                launch: { command: resolved, argsForDir: entry.commandArgs ? ({ workingDir }) => entry.commandArgs({ workingDir }) : ({ workingDir }) => [workingDir] },
-            };
-        }
-    }
-    if (entry.macOpenBundle && probeEnv.platform === 'darwin') {
-        const bundle = await probeMacBundle({ name: entry.macOpenBundle, probeEnv });
-        if (bundle) {
-            return {
-                available: true,
-                resolvedPath: bundle.path,
-                launch: {
-                    command: await resolveMacOpenCommand(probeEnv),
-                    argsForDir: entry.macOpenArgs
-                        ? ({ workingDir }) => entry.macOpenArgs({ bundleName: bundle.name, workingDir })
-                        : ({ workingDir }) => ['-a', bundle.name, workingDir],
-                },
-            };
-        }
-    }
-    return { available: false };
+    return (await resolveViaCommand({ entry, probeEnv })) ?? (await resolveViaMacBundle({ entry, probeEnv })) ?? { available: false };
 }
 /** Resolves the concrete `{command, args}` a caller would spawn to open `workingDir` in `editorId`, or `available: false` if that tool isn't installed/known. */
 export async function resolveHostToolLaunchPlan({ editorId, workingDir }, { probeEnv = defaultProbeEnv({}) } = {}) {
@@ -249,9 +255,6 @@ export async function listAvailableEditors(_required, { probeEnv = defaultProbeE
 }
 /** `GET /api/editors` — lists the host-tool catalogue applicable to this platform with live availability. */
 export const hostEditorsRoute = defineJsonRoute({ method: 'get', path: '/api/editors', parse: () => ok({ value: undefined }), handle: async () => ok({ value: await listAvailableEditors({}) }) });
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
 function parseOpenResourceInEditor(input) {
     const resourceRef = input.params.resourceRef;
     if (typeof resourceRef !== 'string' || resourceRef.length === 0) {
@@ -263,11 +266,31 @@ function parseOpenResourceInEditor(input) {
     if (typeof editorId !== 'string' || editorId.length === 0) {
         return err({ error: validationError({ message: 'editorId is required' }, { issues: [{ path: 'editorId', message: 'required non-empty string' }] }) });
     }
-    const detail = input.body.detail;
-    if (detail !== undefined && (typeof detail !== 'string' || detail.length === 0)) {
-        return err({ error: validationError({ message: 'detail must be a non-empty string when provided' }) });
+    const detail = readOptionalNonEmptyString({ body: input.body, field: 'detail' });
+    if (!detail.ok)
+        return detail;
+    return ok({ value: { resourceRef, editorId, ...withoutUndefined({ detail: detail.value }) } });
+}
+/** Looks `editorId` up in {@link CATALOGUE} and checks it applies to `platform`; both refusals are `BAD_REQUEST`. */
+function selectEditor({ editorId, platform }) {
+    const entry = CATALOGUE.find((c) => c.id === editorId);
+    if (!entry)
+        return err({ error: createApiError({ code: 'BAD_REQUEST', message: `unknown editor: ${editorId}` }) });
+    if (!applicableForPlatform({ entry, platform })) {
+        return err({ error: createApiError({ code: 'BAD_REQUEST', message: `${entry.label} is not available on ${platform}` }) });
+    }
+    return ok({ value: entry });
+}
+/** Probes `entry` and launches it at `workingDir`: `CONFLICT` when it is not installed, `INTERNAL_ERROR` (with the OS's own reason) when the launch is refused. */
+async function launchEditorAt({ entry, workingDir }, { probeEnv, spawnImpl }) {
+    const probe = await resolveEntry({ entry }, { probeEnv });
+    if (!probe.available)
+        return err({ error: createApiError({ code: 'CONFLICT', message: `${entry.label} is not installed` }) });
+    const launch = await launchHostTool({ command: probe.launch.command, args: probe.launch.argsForDir({ workingDir }) }, { spawnImpl });
+    if (!launch.ok) {
+        return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: `failed to launch ${entry.label}: ${launch.error}` }) });
     }
-    return ok({ value: { resourceRef, editorId, ...(detail === undefined ? {} : { detail }) } });
+    return ok({ value: { ok: true, editorId: entry.id, path: workingDir } });
 }
 /**
  * `POST /api/resources/:resourceRef/open-in` — launches `editorId` (from
@@ -293,32 +316,14 @@ function parseOpenResourceInEditor(input) {
  */
 export const openResourceInEditorRoute = defineJsonRoute({
     method: 'post', path: '/api/resources/:resourceRef/open-in', parse: parseOpenResourceInEditor, handle: async ({ input, deps }) => {
-        const entry = CATALOGUE.find((c) => c.id === input.editorId);
-        if (!entry)
-            return err({ error: createApiError({ code: 'BAD_REQUEST', message: `unknown editor: ${input.editorId}` }) });
         const probeEnv = deps.probeEnv ?? defaultProbeEnv({});
-        if (!applicableForPlatform({ entry, platform: probeEnv.platform })) {
-            return err({ error: createApiError({ code: 'BAD_REQUEST', message: `${entry.label} is not available on ${probeEnv.platform}` }) });
-        }
-        let resolvedDir;
-        try {
-            resolvedDir = await resolveWorkspaceRoot({ request: { resourceRef: input.resourceRef, ...(input.detail === undefined ? {} : { detail: input.detail }) } }, { resolver: deps.resolveRoot ?? denyAllWorkspaceRoots });
-        }
-        catch (error) {
-            if (error instanceof WorkspaceRootDeniedError) {
-                return err({ error: createApiError({ code: 'NOT_FOUND', message: `resource "${input.resourceRef}" was not found` }) });
-            }
-            throw error;
-        }
-        const launchPlan = await resolveHostToolLaunchPlan({ editorId: input.editorId, workingDir: resolvedDir }, { probeEnv });
-        if (!launchPlan.available || !launchPlan.command || !launchPlan.args) {
-            return err({ error: createApiError({ code: 'CONFLICT', message: `${entry.label} is not installed` }) });
-        }
-        const launch = await launchHostTool({ command: launchPlan.command, args: launchPlan.args }, { spawnImpl: deps.spawnImpl ?? nodeSpawn });
-        if (!launch.ok) {
-            return err({ error: createApiError({ code: 'INTERNAL_ERROR', message: `failed to launch ${entry.label}: ${launch.error}` }) });
-        }
-        return ok({ value: { ok: true, editorId: input.editorId, path: resolvedDir } });
+        const editor = selectEditor({ editorId: input.editorId, platform: probeEnv.platform });
+        if (!editor.ok)
+            return editor;
+        const root = await resolveResourceRoot({ resourceRef: input.resourceRef, detail: input.detail }, { resolver: deps.resolveRoot ?? denyAllWorkspaceRoots });
+        if (!root.ok)
+            return root;
+        return launchEditorAt({ entry: editor.value, workingDir: root.value }, { probeEnv, spawnImpl: deps.spawnImpl ?? nodeSpawn });
     }
 }, { requireSameOrigin: true });
 /** Mounts `GET /api/editors` and `POST /api/resources/:resourceRef/open-in` on `app`. A pack's `http(app, services)` calls this directly. */

package/dist/http/index.d.ts

@@ -38,8 +38,8 @@ export type { ModelProxyHttpDeps, ModelProxyInternalErrorContext } from './model
 export { registerModelProxyRoutes } from './model-proxy.js';
 export type { HealthHttpDeps, HealthReadinessResult, LivenessResponse, ReadinessResponse, VersionResponse } from './health.js';
 export { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, registerHealthRoutes, versionInfoRoute, } from './health.js';
-export type { AuthCredentials, AuthProvider, AuthSession, AuthUser, Charge, ChargeInput, ChargeStatus, ConnectorsAuthSessionResponse, ConnectorsAuthUserResponse, ConnectorsAuthVerifyResponse, ConnectorsChargeResponse, ConnectorsDbQueryResponse, ConnectorsDbRecordResponse, ConnectorsHttpDeps, ConnectorsInternalErrorContext, ConnectorsOkResponse, ConnectorsStorageGetResponse, ConnectorsStorageListResponse, ConnectorsStorageMetaResponse, DbProvider, DbQuery, DbRecord, PaymentsProvider, RealtimeProvider, StorageObjectMeta, StorageProvider, StoragePutOptions, } from './connectors.js';
-export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsPaymentsChargeRoute, connectorsPaymentsGetRoute, connectorsPaymentsRefundRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
+export type { AuthCredentials, AuthProvider, AuthSession, AuthUser, ConnectorsAuthSessionResponse, ConnectorsAuthUserResponse, ConnectorsAuthVerifyResponse, ConnectorsDbQueryResponse, ConnectorsDbRecordResponse, ConnectorsHttpDeps, ConnectorsInternalErrorContext, ConnectorsOkResponse, ConnectorsStorageGetResponse, ConnectorsStorageListResponse, ConnectorsStorageMetaResponse, DbProvider, DbQuery, DbRecord, RealtimeProvider, StorageObjectMeta, StorageProvider, StoragePutOptions, } from './connectors.js';
+export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
 export type { ResearchProvider, ResearchSearchRequest, ResearchHttpDeps, ResearchInternalErrorContext, ResearchProviderCredentials, ResearchSearchResponse, ResearchSource, } from './research.js';
 export { createResearchSearchRoute, registerResearchRoutes, researchSearchRoute } from './research.js';
 export type { MediaGenerateResponse, MediaHttpDeps, MediaInternalErrorContext, MediaTaskDeleteResponse, MediaTaskListResponse, MediaTaskResponse, } from './media.js';

package/dist/http/index.js

@@ -18,7 +18,7 @@ export { createFrontendControl } from './frontend-control.js';
 export { registerTerminalEventStream, registerTerminalRoutes, terminalCreateRoute, terminalDeleteRoute, terminalKillRoute, terminalListRoute, terminalResizeRoute, terminalStdinRoute, } from './terminals.js';
 export { registerModelProxyRoutes } from './model-proxy.js';
 export { apiHealthRoute, apiReadyRoute, apiVersionInfoRoute, healthRoute, readyRoute, registerHealthRoutes, versionInfoRoute, } from './health.js';
-export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsPaymentsChargeRoute, connectorsPaymentsGetRoute, connectorsPaymentsRefundRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
+export { connectorsAuthSessionRoute, connectorsAuthSignInRoute, connectorsAuthSignOutRoute, connectorsAuthSignUpRoute, connectorsDbDeleteRoute, connectorsDbGetRoute, connectorsDbInsertRoute, connectorsDbQueryRoute, connectorsDbUpdateRoute, connectorsRealtimePublishRoute, connectorsStorageDeleteRoute, connectorsStorageGetRoute, connectorsStorageListRoute, connectorsStoragePutRoute, registerConnectorsRoutes, } from './connectors.js';
 export { createResearchSearchRoute, registerResearchRoutes, researchSearchRoute } from './research.js';
 export { mediaGenerateRoute, mediaTaskDeleteRoute, mediaTaskGetRoute, mediaTaskListRoute, registerMediaRoutes, } from './media.js';
 export { ATTACHMENTS_ROUTE_PATH, AttachmentRejectedError, createDiskAttachmentStore, detectAttachmentKind, handleAttachmentCleanup, handleAttachmentUpload, isUnchangedAttachment, registerAttachmentRoutes, sanitizeAttachmentName, writeBoundedAttachmentBody, } from './attachments.js';

package/dist/http/media.js

@@ -115,85 +115,64 @@ function parseOptionalImageRefs(body) {
     }
     return ok({ value: refs });
 }
+function parseOptionalMember(body, key, allowed) {
+    const value = body[key];
+    if (value === undefined)
+        return ok({ value: undefined });
+    if (typeof value !== 'string' || !allowed.has(value)) {
+        return err({ error: validationError({ message: `${key} must be one of: ${[...allowed].join(', ')} when provided` }) });
+    }
+    return ok({ value });
+}
+/** Table order is the validation order: the first failing field is the one a caller sees. */
+const OPTIONAL_FIELD_PARSERS = [
+    ['audioKind', (body) => parseOptionalMember(body, 'audioKind', AUDIO_KINDS)],
+    ['speechFormat', (body) => parseOptionalMember(body, 'speechFormat', SPEECH_FORMATS)],
+    ['prompt', (body) => parseOptionalString(body, 'prompt')],
+    ['aspect', (body) => parseOptionalString(body, 'aspect')],
+    ['voice', (body) => parseOptionalString(body, 'voice')],
+    ['language', (body) => parseOptionalString(body, 'language')],
+    ['wireModel', (body) => parseOptionalString(body, 'wireModel')],
+    ['length', (body) => parseOptionalNumber(body, 'length')],
+    ['duration', (body) => parseOptionalNumber(body, 'duration')],
+    ['promptInfluence', (body) => parseOptionalNumber(body, 'promptInfluence')],
+    ['loop', (body) => parseOptionalBoolean(body, 'loop')],
+    ['imageRef', parseOptionalImageRef],
+    ['imageRefs', parseOptionalImageRefs],
+];
+/** Collects every provided optional field; an absent field is omitted, never written as `undefined`. */
+function parseOptionalFields(body) {
+    const fields = {};
+    for (const [key, parse] of OPTIONAL_FIELD_PARSERS) {
+        const parsed = parse(body);
+        if (!parsed.ok)
+            return parsed;
+        if (parsed.value !== undefined)
+            fields[key] = parsed.value;
+    }
+    return ok({ value: fields });
+}
+function requiredStringError(key) {
+    return err({ error: validationError({ message: `${key} must be a non-empty string` }, { issues: [{ path: key, message: 'required non-empty string' }] }) });
+}
 function parseMediaGenerate(input) {
     if (!isRecord(input.body))
         return err({ error: validationError({ message: 'body must be a JSON object' }) });
     const body = input.body;
     const ownerRef = requireNonEmptyString(body, 'ownerRef');
-    if (ownerRef === undefined) {
-        return err({ error: validationError({ message: 'ownerRef must be a non-empty string' }, { issues: [{ path: 'ownerRef', message: 'required non-empty string' }] }) });
-    }
+    if (ownerRef === undefined)
+        return requiredStringError('ownerRef');
     const surface = body.surface;
     if (typeof surface !== 'string' || !SURFACES.has(surface)) {
         return err({ error: validationError({ message: 'surface must be one of: image, video, audio' }) });
     }
     const model = requireNonEmptyString(body, 'model');
-    if (model === undefined) {
-        return err({ error: validationError({ message: 'model must be a non-empty string' }, { issues: [{ path: 'model', message: 'required non-empty string' }] }) });
-    }
-    const audioKind = body.audioKind;
-    if (audioKind !== undefined && (typeof audioKind !== 'string' || !AUDIO_KINDS.has(audioKind))) {
-        return err({ error: validationError({ message: 'audioKind must be one of: music, speech, sfx when provided' }) });
-    }
-    const speechFormat = body.speechFormat;
-    if (speechFormat !== undefined && (typeof speechFormat !== 'string' || !SPEECH_FORMATS.has(speechFormat))) {
-        return err({ error: validationError({ message: 'speechFormat must be one of: mp3, wav, flac, aac, opus when provided' }) });
-    }
-    const prompt = parseOptionalString(body, 'prompt');
-    if (!prompt.ok)
-        return prompt;
-    const aspect = parseOptionalString(body, 'aspect');
-    if (!aspect.ok)
-        return aspect;
-    const voice = parseOptionalString(body, 'voice');
-    if (!voice.ok)
-        return voice;
-    const language = parseOptionalString(body, 'language');
-    if (!language.ok)
-        return language;
-    const wireModel = parseOptionalString(body, 'wireModel');
-    if (!wireModel.ok)
-        return wireModel;
-    const length = parseOptionalNumber(body, 'length');
-    if (!length.ok)
-        return length;
-    const duration = parseOptionalNumber(body, 'duration');
-    if (!duration.ok)
-        return duration;
-    const promptInfluence = parseOptionalNumber(body, 'promptInfluence');
-    if (!promptInfluence.ok)
-        return promptInfluence;
-    const loop = parseOptionalBoolean(body, 'loop');
-    if (!loop.ok)
-        return loop;
-    const imageRef = parseOptionalImageRef(body);
-    if (!imageRef.ok)
-        return imageRef;
-    const imageRefs = parseOptionalImageRefs(body);
-    if (!imageRefs.ok)
-        return imageRefs;
-    return ok({
-        value: {
-            ownerRef,
-            request: {
-                surface: surface,
-                model,
-                ...(prompt.value !== undefined ? { prompt: prompt.value } : {}),
-                ...(aspect.value !== undefined ? { aspect: aspect.value } : {}),
-                ...(length.value !== undefined ? { length: length.value } : {}),
-                ...(duration.value !== undefined ? { duration: duration.value } : {}),
-                ...(voice.value !== undefined ? { voice: voice.value } : {}),
-                ...(audioKind !== undefined ? { audioKind: audioKind } : {}),
-                ...(language.value !== undefined ? { language: language.value } : {}),
-                ...(loop.value !== undefined ? { loop: loop.value } : {}),
-                ...(promptInfluence.value !== undefined ? { promptInfluence: promptInfluence.value } : {}),
-                ...(imageRef.value !== undefined ? { imageRef: imageRef.value } : {}),
-                ...(imageRefs.value !== undefined ? { imageRefs: imageRefs.value } : {}),
-                ...(wireModel.value !== undefined ? { wireModel: wireModel.value } : {}),
-                ...(speechFormat !== undefined ? { speechFormat: speechFormat } : {}),
-            },
-        }
-    });
+    if (model === undefined)
+        return requiredStringError('model');
+    const options = parseOptionalFields(body);
+    if (!options.ok)
+        return options;
+    return ok({ value: { ownerRef, request: { surface: surface, model, ...options.value } } });
 }
 function parseTaskId(input) {
     const id = input.params.id;

package/dist/http/memory.js

@@ -1,16 +1,29 @@
 import { createApiError } from '@jini-ai/protocol';
-import { defineJsonRoute, mountJsonRoute } from '@jini-ai/http-kit';
-import { guardSameOrigin } from '@jini-ai/http-kit';
-import { validationError } from '@jini-ai/http-kit';
-import { sendApiError, statusForError } from '@jini-ai/http-kit';
-import { createSseChannel } from '@jini-ai/http-kit';
-import { err, ok } from '@jini-ai/http-kit';
+import { createSseChannel, defineJsonRoute, err, guardSameOrigin, mountJsonRoute, ok, sendApiError, statusForError, validationError, } from '@jini-ai/http-kit';
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
+/** Reads an optional string field: absent (`undefined`) passes through, anything else that is not a string — `null` included — is refused. */
+function readOptionalString(body, key) {
+    const value = body[key];
+    if (value === undefined || typeof value === 'string')
+        return ok({ value });
+    return err({ error: validationError({ message: `${key} must be a string when provided` }) });
+}
+/** Reads a required, non-empty string field, refusing with a per-field validation issue. */
+function readRequiredString(body, key) {
+    const value = body[key];
+    if (typeof value === 'string' && value.length > 0)
+        return ok({ value });
+    return err({ error: validationError({ message: `${key} is required` }, { issues: [{ path: key, message: 'required non-empty string' }] }) });
+}
+/** The `BAD_REQUEST` every mutating route answers when its store call throws, carrying the store's own message. */
+function storeFailure(error) {
+    return err({ error: createApiError({ code: 'BAD_REQUEST', message: errorMessage(error) }) });
+}
 function parseIdParam(input) {
     const id = input.params.id;
     return typeof id === 'string' && id.length > 0 ? ok({ value: id }) : err({ error: validationError({ message: 'id must be a non-empty path parameter' }) });
@@ -45,12 +58,11 @@ function parseUpdateTreeNode(input) {
         return err({ error: validationError({ message: 'body must be a JSON object' }) });
     const patch = {};
     for (const key of ['name', 'description', 'type', 'body']) {
-        const value = input.body[key];
-        if (value === undefined)
-            continue;
-        if (typeof value !== 'string')
-            return err({ error: validationError({ message: `${key} must be a string when provided` }) });
-        patch[key] = value;
+        const value = readOptionalString(input.body, key);
+        if (!value.ok)
+            return value;
+        if (value.value !== undefined)
+            patch[key] = value.value;
     }
     return ok({ value: { id: parsedId.value, patch } });
 }
@@ -105,7 +117,7 @@ export const memoryWriteIndexRoute = defineJsonRoute({
             return ok({ value: { index } });
         }
         catch (error) {
-            return err({ error: createApiError({ code: 'BAD_REQUEST', message: errorMessage(error) }) });
+            return storeFailure(error);
         }
     },
 }, { requireSameOrigin: true });
@@ -128,7 +140,7 @@ export const memoryWriteConfigRoute = defineJsonRoute({
             return ok({ value: { enabled: next.enabled } });
         }
         catch (error) {
-            return err({ error: createApiError({ code: 'BAD_REQUEST', message: errorMessage(error) }) });
+            return storeFailure(error);
         }
     },
 }, { requireSameOrigin: true });
@@ -171,27 +183,24 @@ export const memoryRemoveVerificationRoute = defineJsonRoute({
 function parseEntryInput(input) {
     if (!isRecord(input.body))
         return err({ error: validationError({ message: 'body must be a JSON object' }) });
-    const { name, type } = input.body;
-    if (typeof name !== 'string' || name.length === 0) {
-        return err({ error: validationError({ message: 'name is required' }, { issues: [{ path: 'name', message: 'required non-empty string' }] }) });
-    }
-    if (typeof type !== 'string' || type.length === 0) {
-        return err({ error: validationError({ message: 'type is required' }, { issues: [{ path: 'type', message: 'required non-empty string' }] }) });
-    }
-    const description = input.body.description;
-    if (description !== undefined && typeof description !== 'string') {
-        return err({ error: validationError({ message: 'description must be a string when provided' }) });
-    }
-    const body = input.body.body;
-    if (body !== undefined && typeof body !== 'string') {
-        return err({ error: validationError({ message: 'body must be a string when provided' }) });
-    }
+    const name = readRequiredString(input.body, 'name');
+    if (!name.ok)
+        return name;
+    const type = readRequiredString(input.body, 'type');
+    if (!type.ok)
+        return type;
+    const description = readOptionalString(input.body, 'description');
+    if (!description.ok)
+        return description;
+    const body = readOptionalString(input.body, 'body');
+    if (!body.ok)
+        return body;
     return ok({
         value: {
-            name,
-            type,
-            ...(description === undefined ? {} : { description }),
-            ...(body === undefined ? {} : { body }),
+            name: name.value,
+            type: type.value,
+            ...(description.value === undefined ? {} : { description: description.value }),
+            ...(body.value === undefined ? {} : { body: body.value }),
         }
     });
 }
@@ -205,7 +214,7 @@ export const memoryCreateEntryRoute = defineJsonRoute({
             return ok({ value: { entry } });
         }
         catch (error) {
-            return err({ error: createApiError({ code: 'BAD_REQUEST', message: errorMessage(error) }) });
+            return storeFailure(error);
         }
     },
 }, { requireSameOrigin: true, successStatus: 201 });
@@ -237,7 +246,7 @@ export const memoryUpdateEntryRoute = defineJsonRoute({
             return ok({ value: { entry } });
         }
         catch (error) {
-            return err({ error: createApiError({ code: 'BAD_REQUEST', message: errorMessage(error) }) });
+            return storeFailure(error);
         }
     },
 }, { requireSameOrigin: true });
@@ -251,7 +260,7 @@ export const memoryDeleteEntryRoute = defineJsonRoute({
             return ok({ value: { ok: true } });
         }
         catch (error) {
-            return err({ error: createApiError({ code: 'BAD_REQUEST', message: errorMessage(error) }) });
+            return storeFailure(error);
         }
     },
 }, { requireSameOrigin: true });

package/dist/http/model-proxy-fields.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module model-proxy-fields
+ *
+ * Request-body field helpers for `model-proxy.ts`'s provider parsers: primitive type tests, the
+ * table-driven "optional field present but badly typed" check, the required-field 400 builder, and
+ * the "forward an optional field only when present" copy. Transport-level shape only — nothing here
+ * knows any provider's wire protocol (see `model-proxy.ts`'s module doc).
+ */
+import type { ApiError } from '@jini-ai/protocol';
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function nonEmptyString(value: unknown): string | null;
+export declare const isString: (value: unknown) => boolean;
+export declare const isNumber: (value: unknown) => boolean;
+export declare const isArray: (value: unknown) => boolean;
+/** One optional body field: its name, the primitive-type test it must pass when present, and the 400 message when it does not. */
+export type OptionalFieldCheck = readonly [field: string, isValid: (value: unknown) => boolean, message: string];
+/** The first optional field that is present (not `undefined`) but fails its type test, as a 400 error; `undefined` when every present field is well-typed. */
+export declare function firstOptionalFieldError(record: Record<string, unknown>, checks: readonly OptionalFieldCheck[]): ApiError | undefined;
+/** A 400 for a required field, carrying the single-issue `details` the client can point at. */
+export declare function requiredFieldError(path: string, message: string, issue: string): ApiError;
+/** Copies only the listed keys whose value is not `undefined` — the "forward an optional field only when present" rule every parser and turn-runner call shares. */
+export declare function pickDefined<T extends object, K extends keyof T>(source: T, keys: readonly K[]): Partial<Pick<T, K>>;
+//# sourceMappingURL=model-proxy-fields.d.ts.map