@murphai/murph 0.1.15 → 0.1.18

package/node_modules/@murphai/assistantd/dist/http.js

@@ -0,0 +1,821 @@
+import { timingSafeEqual } from 'node:crypto';
+import { createServer } from 'node:http';
+import { URL } from 'node:url';
+import { assertAssistantCronJobId, assertAssistantOutboxIntentId, assertAssistantSessionId, isAssistantSessionNotFoundError, } from '@murphai/assistant-engine';
+import { gatewayFetchAttachmentsInputSchema, gatewayGetConversationInputSchema, gatewayListConversationsInputSchema, gatewayListOpenPermissionsInputSchema, gatewayPollEventsInputSchema, gatewayReadMessagesInputSchema, gatewayRespondToPermissionInputSchema, gatewaySendMessageInputSchema, gatewayWaitForEventsInputSchema, } from '@murphai/gateway-core';
+import { isLoopbackRemoteAddress } from '@murphai/runtime-state/node';
+const MAX_ASSISTANT_HTTP_BODY_BYTES = 256 * 1024;
+const assistantConversationDirectnessValues = new Set([
+    'direct',
+    'group',
+    'unknown',
+]);
+const assistantOperatorAuthorityValues = new Set([
+    'direct-operator',
+    'accepted-inbound-message',
+]);
+const assistantCanonicalConversationFields = new Set([
+    'alias',
+    'channel',
+    'directness',
+    'identityId',
+    'participantId',
+    'sessionId',
+    'threadId',
+]);
+export async function startAssistantHttpServer(input) {
+    const server = createServer(async (request, response) => {
+        await handleAssistantRequest(request, response, input);
+    });
+    const address = await listenAssistantServer(server, input.host, input.port);
+    return {
+        address: {
+            baseUrl: buildAssistantServerBaseUrl(address),
+            host: address.address,
+            port: address.port,
+        },
+        async close() {
+            await new Promise((resolve, reject) => {
+                server.close((error) => (error ? reject(error) : resolve()));
+            });
+        },
+        server,
+    };
+}
+async function handleAssistantRequest(request, response, input) {
+    try {
+        if (!isLoopbackRemoteAddress(request.socket.remoteAddress)) {
+            sendJson(response, 403, { error: 'Forbidden.' });
+            return;
+        }
+        if (!isAuthorizedAssistantRequest(request, input.controlToken)) {
+            sendJson(response, 401, { error: 'Unauthorized.' });
+            return;
+        }
+        const method = request.method?.toUpperCase() ?? 'GET';
+        const url = new URL(request.url ?? '/', `http://${request.headers.host ?? 'localhost'}`);
+        if (method === 'GET' && url.pathname === '/healthz') {
+            sendJson(response, 200, await input.service.health());
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/open-conversation') {
+            const body = parseOpenConversationRequestBody(await readJsonBody(request));
+            sendJson(response, 200, await input.service.openConversation(body));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/message') {
+            const body = parseAssistantMessageRequestBody(await readJsonBody(request));
+            sendJson(response, 200, await input.service.sendMessage(body));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/session-options') {
+            const body = parseAssistantSessionOptionsRequestBody(await readJsonBody(request));
+            sendJson(response, 200, await input.service.updateSessionOptions(body));
+            return;
+        }
+        if (method === 'GET' && url.pathname === '/status') {
+            sendJson(response, 200, await input.service.getStatus(parseAssistantStatusQuery(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname === '/sessions') {
+            sendJson(response, 200, await input.service.listSessions(parseAssistantVaultQuery(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname.startsWith('/sessions/')) {
+            sendJson(response, 200, await input.service.getSession(parseAssistantSessionRoute(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname === '/outbox') {
+            sendJson(response, 200, await input.service.listOutbox(parseAssistantVaultQuery(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname.startsWith('/outbox/')) {
+            sendJson(response, 200, await input.service.getOutboxIntent(parseAssistantOutboxRoute(url)));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/outbox/drain') {
+            const body = parseAssistantOutboxDrainRequestBody(await readJsonBody(request));
+            sendJson(response, 200, await input.service.drainOutbox(body));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/conversations/list') {
+            const body = parseGatewayListConversationsRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.listConversations(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/conversations/get') {
+            const body = parseGatewayGetConversationRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.getConversation(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/messages/read') {
+            const body = parseGatewayReadMessagesRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.readMessages(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/attachments/fetch') {
+            const body = parseGatewayFetchAttachmentsRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.fetchAttachments(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/messages/send') {
+            const body = parseGatewaySendMessageRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.sendMessage(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/events/poll') {
+            const body = parseGatewayPollEventsRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.pollEvents(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/events/wait') {
+            const body = parseGatewayWaitForEventsRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.waitForEvents(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/permissions/list-open') {
+            const body = parseGatewayListOpenPermissionsRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.listOpenPermissions(gatewayInput));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/gateway/permissions/respond') {
+            const body = parseGatewayRespondToPermissionRequestBody(await readJsonBody(request));
+            const { vault, ...gatewayInput } = body;
+            assertAssistantBoundVault(vault, input.service.vault);
+            sendJson(response, 200, await input.service.gateway.respondToPermission(gatewayInput));
+            return;
+        }
+        if (method === 'GET' && url.pathname === '/cron/status') {
+            sendJson(response, 200, await input.service.getCronStatus(parseAssistantVaultQuery(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname === '/cron/jobs') {
+            sendJson(response, 200, await input.service.listCronJobs(parseAssistantVaultQuery(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname.startsWith('/cron/jobs/') && url.pathname.endsWith('/target')) {
+            sendJson(response, 200, await input.service.getCronTarget(parseAssistantCronTargetRoute(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname.startsWith('/cron/jobs/')) {
+            sendJson(response, 200, await input.service.getCronJob(parseAssistantCronJobRoute(url)));
+            return;
+        }
+        if (method === 'GET' && url.pathname === '/cron/runs') {
+            sendJson(response, 200, await input.service.listCronRuns(parseAssistantCronRunsQuery(url)));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/automation/run-once') {
+            const body = parseAssistantAutomationRunRequestBody(await readJsonBody(request));
+            sendJson(response, 200, await input.service.runAutomationOnce(body));
+            return;
+        }
+        if (method === 'POST' && url.pathname === '/cron/process-due') {
+            const body = parseAssistantCronProcessRequestBody(await readJsonBody(request));
+            sendJson(response, 200, await input.service.processDueCron(body));
+            return;
+        }
+        if (method === 'POST' && url.pathname.startsWith('/cron/jobs/') && url.pathname.endsWith('/target')) {
+            const body = parseAssistantCronTargetSetRequestBody(url, await readJsonBody(request));
+            sendJson(response, 200, await input.service.setCronTarget(body));
+            return;
+        }
+        sendJson(response, 404, { error: 'Not found.' });
+    }
+    catch (error) {
+        const statusCode = resolveAssistantHttpErrorStatus(error);
+        sendJson(response, statusCode, buildAssistantHttpErrorPayload(error, statusCode));
+    }
+}
+async function readJsonBody(request) {
+    const chunks = [];
+    let totalBytes = 0;
+    for await (const chunk of request) {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += buffer.length;
+        if (totalBytes > MAX_ASSISTANT_HTTP_BODY_BYTES) {
+            throw new AssistantHttpRequestError('Assistant daemon request body was too large.', 413);
+        }
+        chunks.push(buffer);
+    }
+    const raw = Buffer.concat(chunks).toString('utf8').trim();
+    return raw.length === 0 ? {} : JSON.parse(raw);
+}
+function parseOpenConversationRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'open-conversation');
+    validateAssistantSessionResolutionRecord(record, 'open-conversation');
+    return record;
+}
+function parseAssistantMessageRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'message');
+    validateAssistantSessionResolutionRecord(record, 'message');
+    const prompt = record.prompt;
+    if (typeof prompt !== 'string' || prompt.trim().length === 0) {
+        throw new AssistantHttpRequestError('Assistant message requests require a non-empty prompt.', 400);
+    }
+    assertOptionalNullableStringField(record, 'deliveryTarget', 'message');
+    assertOptionalNullableStringField(record, 'deliveryReplyToMessageId', 'message');
+    assertOptionalNullableStringField(record, 'operatorAuthority', 'message');
+    assertOptionalNullableStringField(record, 'turnTrigger', 'message');
+    assertOptionalBooleanField(record, 'deliverResponse', 'message');
+    assertOptionalBooleanField(record, 'includeFirstTurnCheckIn', 'message');
+    assertOptionalBooleanField(record, 'persistUserPromptOnFailure', 'message');
+    assertOptionalObjectField(record, 'modelSpec', 'message');
+    if (typeof record.operatorAuthority === 'string' &&
+        !assistantOperatorAuthorityValues.has(record.operatorAuthority)) {
+        throw new AssistantHttpRequestError(`Assistant message operatorAuthority must be one of ${Array.from(assistantOperatorAuthorityValues).join(', ')}.`, 400);
+    }
+    return record;
+}
+function parseAssistantSessionOptionsRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'session-options');
+    const providerOptions = readRequiredRecordField(record, 'providerOptions', 'session-options');
+    return {
+        providerOptions,
+        sessionId: parseAssistantSessionIdField(record.sessionId, 'session-options'),
+        vault: readOptionalNullableStringField(record, 'vault', 'session-options'),
+    };
+}
+function parseAssistantStatusQuery(url) {
+    return {
+        limit: readOptionalIntegerQuery(url, 'limit'),
+        sessionId: readOptionalSessionIdQuery(url, 'sessionId'),
+        vault: readOptionalNullableQuery(url, 'vault'),
+    };
+}
+function parseAssistantVaultQuery(url) {
+    return {
+        vault: readOptionalNullableQuery(url, 'vault'),
+    };
+}
+function assertAssistantBoundVault(requestedVault, configuredVault) {
+    if (!requestedVault || requestedVault === configuredVault) {
+        return;
+    }
+    throw new AssistantHttpRequestError(`assistantd is bound to ${configuredVault}, but the request targeted ${requestedVault}.`, 400);
+}
+function parseAssistantSessionRoute(url) {
+    return {
+        sessionId: parseRequiredOpaqueRouteSegment(url.pathname, '/sessions/', 'session route', parseAssistantSessionIdField),
+        vault: readOptionalNullableQuery(url, 'vault'),
+    };
+}
+function parseAssistantOutboxDrainRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'outbox/drain');
+    return {
+        limit: readOptionalIntegerField(record, 'limit', 'outbox/drain'),
+        now: readOptionalNullableStringField(record, 'now', 'outbox/drain'),
+        vault: readOptionalNullableStringField(record, 'vault', 'outbox/drain'),
+    };
+}
+function parseGatewayListConversationsRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/conversations/list');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayListConversationsInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/conversations/list'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway conversation-list request was invalid.', 400);
+    }
+}
+function parseGatewayGetConversationRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/conversations/get');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayGetConversationInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/conversations/get'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway conversation-get request was invalid.', 400);
+    }
+}
+function parseGatewayReadMessagesRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/messages/read');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayReadMessagesInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/messages/read'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway message-read request was invalid.', 400);
+    }
+}
+function parseGatewayFetchAttachmentsRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/attachments/fetch');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayFetchAttachmentsInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/attachments/fetch'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway attachment-fetch request was invalid.', 400);
+    }
+}
+function parseGatewaySendMessageRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/messages/send');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewaySendMessageInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/messages/send'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway message-send request was invalid.', 400);
+    }
+}
+function parseGatewayPollEventsRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/events/poll');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayPollEventsInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/events/poll'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway event-poll request was invalid.', 400);
+    }
+}
+function parseGatewayWaitForEventsRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/events/wait');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayWaitForEventsInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/events/wait'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway event-wait request was invalid.', 400);
+    }
+}
+function parseGatewayListOpenPermissionsRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/permissions/list-open');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayListOpenPermissionsInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/permissions/list-open'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway permission-list request was invalid.', 400);
+    }
+}
+function parseGatewayRespondToPermissionRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'gateway/permissions/respond');
+    const { vault, ...gatewayRecord } = record;
+    try {
+        return {
+            ...gatewayRespondToPermissionInputSchema.parse(gatewayRecord),
+            vault: typeof vault === 'undefined'
+                ? undefined
+                : readOptionalNullableStringField(record, 'vault', 'gateway/permissions/respond'),
+        };
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error
+            ? error.message
+            : 'Assistant gateway permission-response request was invalid.', 400);
+    }
+}
+function parseAssistantOutboxRoute(url) {
+    return {
+        intentId: parseRequiredOpaqueRouteSegment(url.pathname, '/outbox/', 'outbox route', parseAssistantOutboxIntentIdField),
+        vault: readOptionalNullableQuery(url, 'vault'),
+    };
+}
+function parseAssistantAutomationRunRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'automation/run-once');
+    assertOptionalNullableStringField(record, 'vault', 'automation/run-once');
+    assertOptionalNullableStringField(record, 'requestId', 'automation/run-once');
+    assertOptionalBooleanField(record, 'allowSelfAuthored', 'automation/run-once');
+    assertOptionalBooleanField(record, 'drainOutbox', 'automation/run-once');
+    assertOptionalBooleanField(record, 'once', 'automation/run-once');
+    assertOptionalBooleanField(record, 'startDaemon', 'automation/run-once');
+    assertOptionalFiniteNumberField(record, 'maxPerScan', 'automation/run-once');
+    assertOptionalFiniteNumberField(record, 'scanIntervalMs', 'automation/run-once');
+    assertOptionalFiniteNumberField(record, 'sessionMaxAgeMs', 'automation/run-once');
+    const deliveryDispatchMode = readOptionalNullableStringField(record, 'deliveryDispatchMode', 'automation/run-once');
+    if (deliveryDispatchMode !== null &&
+        deliveryDispatchMode !== undefined &&
+        deliveryDispatchMode !== 'immediate' &&
+        deliveryDispatchMode !== 'queue-only') {
+        throw new AssistantHttpRequestError('Assistant automation run requests must use a valid deliveryDispatchMode.', 400);
+    }
+    assertOptionalObjectField(record, 'modelSpec', 'automation/run-once');
+    return {
+        ...record,
+        deliveryDispatchMode: deliveryDispatchMode ?? undefined,
+    };
+}
+function parseAssistantCronProcessRequestBody(payload) {
+    const record = asAssistantRequestRecord(payload, 'cron/process-due');
+    const deliveryDispatchMode = readOptionalNullableStringField(record, 'deliveryDispatchMode', 'cron/process-due');
+    if (deliveryDispatchMode !== null &&
+        deliveryDispatchMode !== undefined &&
+        deliveryDispatchMode !== 'immediate' &&
+        deliveryDispatchMode !== 'queue-only') {
+        throw new AssistantHttpRequestError('Assistant cron process requests must use a valid deliveryDispatchMode.', 400);
+    }
+    return {
+        deliveryDispatchMode: deliveryDispatchMode ?? undefined,
+        limit: readOptionalIntegerField(record, 'limit', 'cron/process-due'),
+        vault: readOptionalNullableStringField(record, 'vault', 'cron/process-due'),
+    };
+}
+function parseAssistantCronTargetSetRequestBody(url, payload) {
+    const record = asAssistantRequestRecord(payload, 'cron target');
+    assertOptionalNullableStringField(record, 'vault', 'cron target');
+    assertOptionalNullableStringField(record, 'channel', 'cron target');
+    assertOptionalNullableStringField(record, 'identityId', 'cron target');
+    assertOptionalNullableStringField(record, 'participantId', 'cron target');
+    assertOptionalNullableStringField(record, 'sourceThreadId', 'cron target');
+    assertOptionalNullableStringField(record, 'deliveryTarget', 'cron target');
+    assertOptionalBooleanField(record, 'dryRun', 'cron target');
+    assertOptionalBooleanField(record, 'resetContinuity', 'cron target');
+    return {
+        job: parseAssistantCronTargetJobIdFromPath(url.pathname),
+        vault: readOptionalNullableStringField(record, 'vault', 'cron target'),
+        channel: readOptionalNullableStringField(record, 'channel', 'cron target'),
+        identityId: readOptionalNullableStringField(record, 'identityId', 'cron target'),
+        participantId: readOptionalNullableStringField(record, 'participantId', 'cron target'),
+        sourceThreadId: readOptionalNullableStringField(record, 'sourceThreadId', 'cron target'),
+        deliveryTarget: readOptionalNullableStringField(record, 'deliveryTarget', 'cron target'),
+        dryRun: readOptionalBooleanField(record, 'dryRun', 'cron target'),
+        resetContinuity: readOptionalBooleanField(record, 'resetContinuity', 'cron target'),
+    };
+}
+function parseAssistantCronJobRoute(url) {
+    return {
+        job: parseRequiredOpaqueRouteSegment(url.pathname, '/cron/jobs/', 'cron job route', parseAssistantCronJobIdField),
+        vault: readOptionalNullableQuery(url, 'vault'),
+    };
+}
+function parseAssistantCronTargetRoute(url) {
+    return {
+        job: parseAssistantCronTargetJobIdFromPath(url.pathname),
+        vault: readOptionalNullableQuery(url, 'vault'),
+    };
+}
+function parseAssistantCronTargetJobIdFromPath(pathname) {
+    if (!pathname.startsWith('/cron/jobs/') || !pathname.endsWith('/target')) {
+        throw new AssistantHttpRequestError('Assistant cron target route requires a cron job id.', 400);
+    }
+    try {
+        return parseAssistantCronJobIdField(decodeURIComponent(pathname.slice('/cron/jobs/'.length, -'/target'.length)), 'cron target route');
+    }
+    catch (error) {
+        if (error instanceof AssistantHttpRequestError) {
+            throw error;
+        }
+        throw new AssistantHttpRequestError('Assistant cron target route contained an invalid encoding.', 400);
+    }
+}
+function parseAssistantCronRunsQuery(url) {
+    const job = readOptionalNullableQuery(url, 'job');
+    if (typeof job !== 'string' || job.length === 0) {
+        throw new AssistantHttpRequestError('Assistant cron runs requests require a job query parameter.', 400);
+    }
+    return {
+        job: parseAssistantCronJobIdField(job, 'cron runs query'),
+        limit: readOptionalIntegerQuery(url, 'limit'),
+        vault: readOptionalNullableQuery(url, 'vault'),
+    };
+}
+function validateAssistantSessionResolutionRecord(record, context) {
+    assertOptionalNullableStringField(record, 'vault', context);
+    assertOptionalNullableStringField(record, 'alias', context);
+    assertOptionalNullableStringField(record, 'sessionId', context);
+    if (typeof record.sessionId === 'string') {
+        parseAssistantSessionIdField(record.sessionId, context);
+    }
+    assertOptionalNullableStringField(record, 'channel', context);
+    assertOptionalNullableStringField(record, 'identityId', context);
+    assertOptionalNullableStringField(record, 'participantId', context);
+    assertOptionalNullableStringField(record, 'sourceThreadId', context);
+    assertOptionalNullableStringField(record, 'threadId', context);
+    assertOptionalNullableStringField(record, 'provider', context);
+    assertOptionalNullableStringField(record, 'model', context);
+    assertOptionalNullableStringField(record, 'reasoningEffort', context);
+    assertOptionalNullableStringField(record, 'sandbox', context);
+    assertOptionalNullableStringField(record, 'approvalPolicy', context);
+    assertOptionalNullableStringField(record, 'codexProfile', context);
+    assertOptionalNullableStringField(record, 'codexCommand', context);
+    assertOptionalNullableStringField(record, 'workingDirectory', context);
+    assertOptionalNullableStringField(record, 'now', context);
+    assertOptionalBooleanField(record, 'threadIsDirect', context);
+    assertOptionalBooleanField(record, 'oss', context);
+    assertOptionalFiniteNumberField(record, 'maxSessionAgeMs', context);
+    const conversation = record.conversation;
+    if (conversation !== undefined) {
+        const conversationRecord = readRequiredRecordField(record, 'conversation', context);
+        validateAssistantConversationRecord(conversationRecord, context);
+    }
+}
+function validateAssistantConversationRecord(record, context) {
+    for (const key of Object.keys(record)) {
+        if (!assistantCanonicalConversationFields.has(key)) {
+            throw new AssistantHttpRequestError(`Assistant ${context} conversation field ${key} is not supported. Use the canonical nested conversation-ref shape instead.`, 400);
+        }
+    }
+    const nestedContext = `${context} conversation`;
+    const nestedSessionId = record.sessionId;
+    if (typeof nestedSessionId === 'string') {
+        parseAssistantSessionIdField(nestedSessionId, nestedContext);
+    }
+    else if (nestedSessionId !== undefined && nestedSessionId !== null) {
+        throw new AssistantHttpRequestError(`Assistant ${nestedContext} sessionId must be a string when present.`, 400);
+    }
+    assertOptionalNullableStringField(record, 'alias', nestedContext);
+    assertOptionalNullableStringField(record, 'channel', nestedContext);
+    assertOptionalNullableStringField(record, 'identityId', nestedContext);
+    assertOptionalNullableStringField(record, 'participantId', nestedContext);
+    assertOptionalNullableStringField(record, 'threadId', nestedContext);
+    const directness = readOptionalNullableStringField(record, 'directness', nestedContext);
+    if (directness !== undefined &&
+        directness !== null &&
+        !assistantConversationDirectnessValues.has(directness)) {
+        throw new AssistantHttpRequestError(`Assistant ${nestedContext} directness must be one of direct, group, or unknown when present.`, 400);
+    }
+}
+function asAssistantRequestRecord(payload, context) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new AssistantHttpRequestError(`Assistant ${context} requests must use a JSON object body.`, 400);
+    }
+    return payload;
+}
+function readRequiredRecordField(record, key, context) {
+    const value = record[key];
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new AssistantHttpRequestError(`Assistant ${context} request field ${key} must be a JSON object.`, 400);
+    }
+    return value;
+}
+function readOptionalNullableStringField(record, key, context) {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === null) {
+        return null;
+    }
+    if (typeof value !== 'string') {
+        throw new AssistantHttpRequestError(`Assistant ${context} request field ${key} must be a string when present.`, 400);
+    }
+    return value;
+}
+function assertOptionalNullableStringField(record, key, context) {
+    void readOptionalNullableStringField(record, key, context);
+}
+function assertOptionalBooleanField(record, key, context) {
+    const value = record[key];
+    if (value !== undefined && typeof value !== 'boolean') {
+        throw new AssistantHttpRequestError(`Assistant ${context} request field ${key} must be a boolean when present.`, 400);
+    }
+}
+function readOptionalBooleanField(record, key, context) {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'boolean') {
+        throw new AssistantHttpRequestError(`Assistant ${context} request field ${key} must be a boolean when present.`, 400);
+    }
+    return value;
+}
+function assertOptionalFiniteNumberField(record, key, context) {
+    const value = record[key];
+    if (value !== undefined &&
+        (typeof value !== 'number' || !Number.isFinite(value))) {
+        throw new AssistantHttpRequestError(`Assistant ${context} request field ${key} must be a finite number when present.`, 400);
+    }
+}
+function assertOptionalObjectField(record, key, context) {
+    const value = record[key];
+    if (value !== undefined && (!value || typeof value !== 'object' || Array.isArray(value))) {
+        throw new AssistantHttpRequestError(`Assistant ${context} request field ${key} must be a JSON object when present.`, 400);
+    }
+}
+function readOptionalIntegerField(record, key, context) {
+    const value = record[key];
+    if (value === undefined) {
+        return undefined;
+    }
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        throw new AssistantHttpRequestError(`Assistant ${context} request field ${key} must be a finite number when present.`, 400);
+    }
+    return Math.trunc(value);
+}
+function readOptionalIntegerQuery(url, key) {
+    const raw = readOptionalNullableQuery(url, key);
+    if (!raw) {
+        return undefined;
+    }
+    const value = Number(raw);
+    if (!Number.isFinite(value)) {
+        throw new AssistantHttpRequestError(`Assistant query parameter ${key} must be a finite number when present.`, 400);
+    }
+    return Math.trunc(value);
+}
+function readOptionalNullableQuery(url, key) {
+    const value = url.searchParams.get(key);
+    return value === null ? undefined : value;
+}
+function readOptionalSessionIdQuery(url, key) {
+    const value = readOptionalNullableQuery(url, key);
+    if (typeof value !== 'string' || value.length === 0) {
+        return value;
+    }
+    return parseAssistantSessionIdField(value, `query parameter ${key}`);
+}
+function parseAssistantSessionIdField(value, context) {
+    if (typeof value !== 'string') {
+        throw new AssistantHttpRequestError(`Assistant ${context} session id must be a string.`, 400);
+    }
+    try {
+        return assertAssistantSessionId(value);
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error ? error.message : 'Assistant session id was invalid.', 400, readAssistantErrorCode(error));
+    }
+}
+function parseAssistantOutboxIntentIdField(value, context) {
+    if (typeof value !== 'string') {
+        throw new AssistantHttpRequestError(`Assistant ${context} outbox intent id must be a string.`, 400);
+    }
+    try {
+        return assertAssistantOutboxIntentId(value);
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error ? error.message : 'Assistant outbox intent id was invalid.', 400, readAssistantErrorCode(error));
+    }
+}
+function parseAssistantCronJobIdField(value, context) {
+    if (typeof value !== 'string') {
+        throw new AssistantHttpRequestError(`Assistant ${context} cron job id must be a string.`, 400);
+    }
+    try {
+        return assertAssistantCronJobId(value);
+    }
+    catch (error) {
+        throw new AssistantHttpRequestError(error instanceof Error ? error.message : 'Assistant cron job id was invalid.', 400, readAssistantErrorCode(error));
+    }
+}
+function parseRequiredOpaqueRouteSegment(pathname, prefix, context, parseValue) {
+    return parseValue(parseRequiredRouteSegment(pathname, prefix, context), context);
+}
+function parseRequiredRouteSegment(pathname, prefix, context) {
+    const encoded = pathname.startsWith(prefix) ? pathname.slice(prefix.length) : '';
+    if (!encoded) {
+        throw new AssistantHttpRequestError(`Assistant ${context} requires an identifier.`, 400);
+    }
+    try {
+        return decodeURIComponent(encoded);
+    }
+    catch {
+        throw new AssistantHttpRequestError(`Assistant ${context} contained an invalid encoding.`, 400);
+    }
+}
+function resolveAssistantHttpErrorStatus(error) {
+    if (error instanceof AssistantHttpRequestError) {
+        return error.statusCode;
+    }
+    if (error instanceof SyntaxError) {
+        return 400;
+    }
+    const code = readAssistantErrorCode(error);
+    if (code === 'ASSISTANT_INVALID_RUNTIME_ID' || code === 'ASSISTANT_STATE_INVALID_DOC_ID') {
+        return 400;
+    }
+    if (code === 'ASSISTANT_SESSION_NOT_FOUND' || code === 'ASSISTANT_CRON_JOB_NOT_FOUND') {
+        return 404;
+    }
+    if (isAssistantSessionNotFoundError(error)) {
+        return 404;
+    }
+    return 500;
+}
+function buildAssistantHttpErrorPayload(error, statusCode) {
+    const code = statusCode < 500 ? readAssistantErrorCode(error) : null;
+    return {
+        ...(code ? { code } : {}),
+        error: statusCode >= 500
+            ? 'Assistant daemon request failed.'
+            : error instanceof Error
+                ? error.message
+                : 'Assistant daemon request failed.',
+    };
+}
+function readAssistantErrorCode(error) {
+    if (!error || typeof error !== 'object' || !('code' in error)) {
+        return null;
+    }
+    const value = error.code;
+    return typeof value === 'string' && value.length > 0 ? value : null;
+}
+function isAuthorizedAssistantRequest(request, expectedToken) {
+    const header = request.headers.authorization;
+    if (typeof header !== 'string') {
+        return false;
+    }
+    const matched = header.match(/^bearer\s+(.+)$/iu);
+    if (!matched?.[1]) {
+        return false;
+    }
+    const provided = Buffer.from(matched[1], 'utf8');
+    const expected = Buffer.from(expectedToken, 'utf8');
+    return provided.length === expected.length && timingSafeEqual(provided, expected);
+}
+function buildAssistantServerBaseUrl(address) {
+    const host = address.family === 'IPv6' ? `[${address.address}]` : address.address;
+    return `http://${host}:${address.port}`;
+}
+function sendJson(response, statusCode, payload) {
+    response.statusCode = statusCode;
+    response.setHeader('Content-Type', 'application/json; charset=utf-8');
+    response.end(`${JSON.stringify(payload)}\n`);
+}
+async function listenAssistantServer(server, host, port) {
+    await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(port, host, () => {
+            server.off('error', reject);
+            resolve();
+        });
+    });
+    const address = server.address();
+    if (!address || typeof address === 'string') {
+        throw new Error('assistantd did not expose a TCP listener address.');
+    }
+    return address;
+}
+class AssistantHttpRequestError extends Error {
+    statusCode;
+    code;
+    constructor(message, statusCode, code) {
+        super(message);
+        this.statusCode = statusCode;
+        this.code = code;
+        this.name = 'AssistantHttpRequestError';
+    }
+}
+//# sourceMappingURL=http.js.map