dsh-agy-cli 0.0.0-stage → 0.12.0

package/lib/provider/serialize.js

@@ -0,0 +1,82 @@
+export class AgyPromptError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'AgyPromptError';
+    }
+}
+function blockText(block, messageIndex, blockIndex) {
+    switch (block.type) {
+        case 'text':
+            return block.text;
+        case 'reasoning':
+            return `[reasoning]\n${block.text}`;
+        case 'tool-call':
+            return `[DSH TOOL CALL]\n${JSON.stringify({
+                id: block.id,
+                name: block.name,
+                arguments: block.arguments,
+            })}`;
+        default:
+            throw new AgyPromptError(`AGY text MVP does not support content block ${block.type} at message ${messageIndex}, block ${blockIndex}`, 'UNSUPPORTED_CONTENT');
+    }
+}
+function blockValue(block, messageIndex, blockIndex) {
+    switch (block.type) {
+        case 'text':
+            return { type: 'text', text: block.text };
+        case 'reasoning':
+            return { type: 'reasoning', text: block.text };
+        case 'tool-call':
+            return { type: 'tool-call', id: block.id, name: block.name, arguments: block.arguments };
+        default:
+            throw new AgyPromptError(`AGY text MVP does not support content block ${block.type} at message ${messageIndex}, block ${blockIndex}`, 'UNSUPPORTED_CONTENT');
+    }
+}
+function messageText(message, messageIndex) {
+    // 0.2.0 moved tool results out of content blocks into a first-class tool-role
+    // message; the flat text prompt keeps the same [DSH TOOL RESULT] rendering.
+    if (message.role === 'tool') {
+        return `[DSH TOOL RESULT]\n${JSON.stringify({
+            callId: message.toolCallId,
+            isError: message.isError === true,
+            content: message.content.map((block, blockIndex) => blockValue(block, messageIndex, String(blockIndex))),
+        })}`;
+    }
+    return message.content
+        .map((block, blockIndex) => blockText(block, messageIndex, blockIndex))
+        .join('\n');
+}
+function roleLabel(message) {
+    return message.role.toUpperCase();
+}
+/** Serialize the DSH request into a deterministic, text-only AGY prompt. */
+export function serializeAgyPrompt(options) {
+    const sections = [];
+    if (options.system !== undefined && options.system.length > 0) {
+        sections.push(`=== SYSTEM ===\n${options.system}`);
+    }
+    options.messages.forEach((message, messageIndex) => {
+        sections.push(`=== ${roleLabel(message)} ===\n${messageText(message, messageIndex)}`);
+    });
+    if (sections.length === 0) {
+        throw new AgyPromptError('AGY text MVP requires a non-empty system or message prompt', 'EMPTY_PROMPT');
+    }
+    return sections.join('\n\n');
+}
+/**
+ * Serialize only the messages added after the previous assistant turn.
+ * AGY already owns the earlier turns when `--conversation` is used; sending
+ * the complete DSH history again would duplicate context and spend quota.
+ */
+export function serializeAgyTurnPrompt(options) {
+    let lastAssistant = -1;
+    options.messages.forEach((message, index) => {
+        if (message.role === 'assistant')
+            lastAssistant = index;
+    });
+    const messages = options.messages.slice(lastAssistant + 1);
+    return serializeAgyPrompt({ messages });
+}
+//# sourceMappingURL=serialize.js.map

package/lib/provider/tool-protocol.d.ts

@@ -0,0 +1,80 @@
+import type { ToolSchema } from '@deepseek-ai/dsh-llm';
+/** Upper bounds for the provider-side structured tool protocol. */
+export declare const TOOL_PROTOCOL_LIMITS: Readonly<{
+    maxTools: 256;
+    maxToolNameLength: 128;
+    maxDescriptionLength: 4096;
+    maxSchemaDepth: 10;
+    maxSchemaBytes: number;
+    maxArgumentsBytes: number;
+    maxMessageLength: number;
+    maxResultBytes: number;
+    maxPromptContractBytes: number;
+}>;
+export declare const TOOL_PROTOCOL_SCHEMA_INVALID_CODE: "TOOL_PROTOCOL_SCHEMA_INVALID";
+export declare const TOOL_PROTOCOL_SCHEMA_LIMIT_CODE: "TOOL_PROTOCOL_SCHEMA_LIMIT";
+export declare const TOOL_PROTOCOL_RESPONSE_INVALID_CODE: "TOOL_PROTOCOL_RESPONSE_INVALID";
+export declare const TOOL_PROTOCOL_UNKNOWN_TOOL_CODE: "TOOL_PROTOCOL_UNKNOWN_TOOL";
+export declare const TOOL_PROTOCOL_ARGUMENTS_INVALID_CODE: "TOOL_PROTOCOL_ARGUMENTS_INVALID";
+export declare const TOOL_PROTOCOL_RESPONSE_LIMIT_CODE: "TOOL_PROTOCOL_RESPONSE_LIMIT";
+export type ToolProtocolErrorCode = typeof TOOL_PROTOCOL_ARGUMENTS_INVALID_CODE | typeof TOOL_PROTOCOL_RESPONSE_INVALID_CODE | typeof TOOL_PROTOCOL_RESPONSE_LIMIT_CODE | typeof TOOL_PROTOCOL_SCHEMA_INVALID_CODE | typeof TOOL_PROTOCOL_SCHEMA_LIMIT_CODE | typeof TOOL_PROTOCOL_UNKNOWN_TOOL_CODE;
+/** Safe, value-free diagnosis for a rejected tool argument object. */
+export type ToolProtocolArgumentIssue = 'missing-required' | 'unexpected-property' | 'type' | 'enum' | 'constraint' | 'combinator' | 'unknown';
+export interface ToolProtocolArgumentDiagnostic {
+    readonly toolName: string;
+    readonly issue: ToolProtocolArgumentIssue;
+    readonly path?: string;
+    readonly missingRequiredKeys?: readonly string[];
+    readonly receivedArgumentKeys?: readonly string[];
+}
+export type ToolProtocolCompatibility = 'pwsh-description-default' | 'json-control-character-escape' | 'agy-call-envelope' | 'agy-command-envelope' | 'agy-thought-call-envelope' | 'agy-bare-call-envelope';
+export interface ParseStructuredEnvelopeOptions {
+    readonly onCompatibilityApplied?: (compatibility: ToolProtocolCompatibility) => void;
+}
+/** Stable error that never embeds raw prompts, arguments, schemas, or paths. */
+export declare class ToolProtocolError extends Error {
+    readonly code: ToolProtocolErrorCode;
+    readonly detail: string | undefined;
+    readonly diagnostic: ToolProtocolArgumentDiagnostic | undefined;
+    constructor(code: ToolProtocolErrorCode, detail?: string, diagnostic?: ToolProtocolArgumentDiagnostic);
+}
+export type StructuredEnvelope = {
+    readonly kind: 'message';
+    readonly content: string;
+} | {
+    readonly kind: 'tool_call';
+    readonly name: string;
+    readonly arguments: Record<string, unknown>;
+};
+export interface StructuredToolProtocol {
+    readonly schema: Record<string, unknown>;
+    readonly schemaJson: string;
+    /** SHA-256 of the canonical schema JSON; safe to emit as diagnostics. */
+    readonly schemaHash: string;
+    readonly tools: readonly ToolSchema[];
+}
+/**
+ * Whitelist one JSON Schema down to the keywords the DSH tool protocol
+ * supports. Exported so the MCP tool projection can reuse exactly the same
+ * gate instead of duplicating the keyword policy.
+ */
+export declare function sanitizeSchema(value: unknown, depth: number, label: string): unknown;
+/** Render the DSH-owned protocol as bounded data inside an AGY text prompt. */
+export declare function renderToolProtocolPrompt(protocol: StructuredToolProtocol): string;
+/** Append the immutable protocol contract after the serialized DSH history. */
+export declare function appendToolProtocolPrompt(prompt: string, protocol: StructuredToolProtocol): string;
+export type ToolProtocolRepairReason = 'internal-tool-event';
+/** Add one bounded repair instruction after the protocol contract. */
+export declare function appendToolProtocolRepairPrompt(prompt: string, hint?: Pick<ToolProtocolArgumentDiagnostic, 'toolName' | 'issue' | 'missingRequiredKeys'>, reason?: ToolProtocolRepairReason): string;
+/** Convert DSH tool schemas into one strict, bounded AGY final-result schema. */
+export declare function createStructuredToolProtocol(tools: readonly ToolSchema[]): StructuredToolProtocol;
+/** Strictly parse and validate AGY's final structured response. */
+export declare function parseStructuredEnvelope(raw: unknown, protocolOrTools: StructuredToolProtocol | readonly ToolSchema[], options?: ParseStructuredEnvelopeOptions): StructuredEnvelope;
+/** Accumulate fragmented AGY result text without accepting an early partial JSON value. */
+export declare class StructuredResponseAccumulator {
+    private text;
+    append(fragment: string): void;
+    parse(protocolOrTools: StructuredToolProtocol | readonly ToolSchema[]): StructuredEnvelope;
+    get length(): number;
+}
+//# sourceMappingURL=tool-protocol.d.ts.map