@mastra/server 1.20.0 → 1.21.0-alpha.0

package/dist/server/handlers/responses.adapter.d.ts

@@ -0,0 +1,98 @@
+import type { MastraDBMessage } from '@mastra/core/agent';
+import type { ConversationItem, ResponseInputMessage, ResponseObject, ResponseOutputItem, ResponseTextConfig, ResponseTool } from '../schemas/responses.js';
+import type { ProviderMetadataLike, ResponseTurnRecord, UsageLike } from './responses.storage.js';
+export type ResponseExecutionMessage = {
+    role: 'system' | 'user' | 'assistant';
+    content: string;
+};
+/**
+ * Maps configured Mastra tools into Responses API tool definitions.
+ */
+export declare function mapMastraToolsToResponseTools(tools: Record<string, unknown> | undefined): ResponseTool[];
+/**
+ * Maps Mastra thread messages into OpenAI-style conversation items.
+ */
+export declare function mapMastraMessagesToConversationItems(messages: MastraDBMessage[]): ConversationItem[];
+/**
+ * Maps the stored Mastra messages for one response turn back into OpenAI-style
+ * `response.output` items, preserving tool/message ordering from the thread.
+ */
+export declare function mapMastraMessagesToResponseOutputItems({ messages, outputMessageId, status, fallbackText, }: {
+    messages: MastraDBMessage[] | undefined;
+    outputMessageId: string;
+    status: ResponseObject['status'];
+    fallbackText: string;
+}): ResponseOutputItem[];
+/**
+ * Creates a stable assistant-message-backed response identifier.
+ */
+export declare function createMessageId(): string;
+/**
+ * Maps Responses API input into the plain execution messages Mastra agents expect.
+ */
+export declare function mapResponseInputToExecutionMessages(input: ResponseInputMessage[] | string): ResponseExecutionMessage[];
+/**
+ * Converts usage details to the Responses API usage shape.
+ */
+export declare function toResponseUsage(usage: UsageLike): ResponseObject['usage'];
+/**
+ * Maps model finish reasons onto the Responses API status field.
+ */
+export declare function toResponseStatus(finishReason: string | undefined): ResponseObject['status'];
+/**
+ * Formats a text response part using the OpenAI-compatible Responses shape.
+ */
+export declare function createOutputTextPart(text: string): {
+    type: "output_text";
+    text: string;
+    annotations: unknown[];
+    logprobs: unknown[];
+};
+/**
+ * Builds a completed Responses API object from Mastra execution state.
+ */
+export declare function buildCompletedResponse({ responseId, outputMessageId, model, createdAt, completedAt, status, text, usage, instructions, textConfig, previousResponseId, conversationId, providerOptions, tools, store, messages, }: {
+    responseId: string;
+    outputMessageId: string;
+    model: string;
+    createdAt: number;
+    completedAt: number | null;
+    status: ResponseObject['status'];
+    text: string;
+    usage: UsageLike;
+    instructions?: string;
+    textConfig?: ResponseTextConfig;
+    previousResponseId?: string;
+    conversationId?: string;
+    providerOptions?: ProviderMetadataLike;
+    tools: ResponseTool[];
+    store: boolean;
+    messages?: MastraDBMessage[];
+}): ResponseObject;
+/**
+ * Builds the initial in-progress Responses API object emitted at stream start.
+ */
+export declare function buildInProgressResponse({ responseId, model, createdAt, instructions, textConfig, previousResponseId, conversationId, tools, store, }: {
+    responseId: string;
+    model: string;
+    createdAt: number;
+    instructions?: string;
+    textConfig?: ResponseTextConfig;
+    previousResponseId?: string;
+    conversationId?: string;
+    store: boolean;
+    tools?: ResponseTool[];
+}): ResponseObject;
+/**
+ * Reconstructs a Responses API object from a stored response-turn record.
+ */
+export declare function mapResponseTurnRecordToResponse(match: ResponseTurnRecord): ResponseObject;
+/**
+ * Formats an SSE event line for the streaming Responses route.
+ */
+export declare function formatSseEvent(event: string, data: unknown): Uint8Array;
+/**
+ * Extracts text deltas from the Mastra stream chunk variants used by the route.
+ */
+export declare function extractTextDelta(value: unknown): string | null;
+//# sourceMappingURL=responses.adapter.d.ts.map

package/dist/server/handlers/responses.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.adapter.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/responses.adapter.ts"],"names":[],"mappings":"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"}

package/dist/server/handlers/responses.adapter.js

@@ -0,0 +1,3 @@
+export { buildCompletedResponse, buildInProgressResponse, createMessageId, createOutputTextPart, extractTextDelta, formatSseEvent, mapMastraMessagesToConversationItems, mapMastraMessagesToResponseOutputItems, mapMastraToolsToResponseTools, mapResponseInputToExecutionMessages, mapResponseTurnRecordToResponse, toResponseStatus, toResponseUsage } from '../../chunk-AJYJ4H7P.js';
+//# sourceMappingURL=responses.adapter.js.map
+//# sourceMappingURL=responses.adapter.js.map

package/dist/server/handlers/responses.adapter.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"responses.adapter.js"}

package/dist/server/handlers/responses.cjs

@@ -0,0 +1,20 @@
+'use strict';
+
+var chunk3VVDBDS5_cjs = require('../../chunk-3VVDBDS5.cjs');
+
+
+
+Object.defineProperty(exports, "CREATE_RESPONSE_ROUTE", {
+  enumerable: true,
+  get: function () { return chunk3VVDBDS5_cjs.CREATE_RESPONSE_ROUTE; }
+});
+Object.defineProperty(exports, "DELETE_RESPONSE_ROUTE", {
+  enumerable: true,
+  get: function () { return chunk3VVDBDS5_cjs.DELETE_RESPONSE_ROUTE; }
+});
+Object.defineProperty(exports, "GET_RESPONSE_ROUTE", {
+  enumerable: true,
+  get: function () { return chunk3VVDBDS5_cjs.GET_RESPONSE_ROUTE; }
+});
+//# sourceMappingURL=responses.cjs.map
+//# sourceMappingURL=responses.cjs.map

package/dist/server/handlers/responses.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"responses.cjs"}

package/dist/server/handlers/responses.d.ts

@@ -0,0 +1,387 @@
+export declare const CREATE_RESPONSE_ROUTE: import("../server-adapter").ServerRoute<{
+    [x: string]: unknown;
+    model: string;
+    input: string | {
+        role: "system" | "user" | "assistant" | "developer";
+        content: string | {
+            type: "text" | "input_text" | "output_text";
+            text: string;
+        }[];
+    }[];
+    stream: boolean;
+    store: boolean;
+    agent_id?: string | undefined;
+    instructions?: string | undefined;
+    text?: {
+        format: {
+            type: "json_object";
+        } | {
+            type: "json_schema";
+            name: string;
+            schema: Record<string, unknown>;
+            description?: string | undefined;
+            strict?: boolean | undefined;
+        };
+    } | undefined;
+    conversation_id?: string | undefined;
+    providerOptions?: {
+        [x: string]: unknown;
+        openai?: Record<string, unknown> | undefined;
+    } | undefined;
+    previous_response_id?: string | undefined;
+}, {
+    id: string;
+    object: "response";
+    created_at: number;
+    completed_at: number | null;
+    model: string;
+    status: "completed" | "in_progress" | "incomplete";
+    output: ({
+        id: string;
+        type: "message";
+        role: "assistant";
+        status: "completed" | "in_progress" | "incomplete";
+        content: {
+            type: "output_text";
+            text: string;
+            annotations?: unknown[] | undefined;
+            logprobs?: unknown[] | undefined;
+        }[];
+    } | {
+        id: string;
+        type: "function_call";
+        call_id: string;
+        name: string;
+        arguments: string;
+        status?: "completed" | "in_progress" | "incomplete" | undefined;
+    } | {
+        id: string;
+        type: "function_call_output";
+        call_id: string;
+        output: string;
+    })[];
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+        input_tokens_details?: {
+            cached_tokens: number;
+        } | undefined;
+        output_tokens_details?: {
+            reasoning_tokens: number;
+        } | undefined;
+    } | null;
+    error?: null | undefined;
+    incomplete_details?: null | undefined;
+    instructions?: string | null | undefined;
+    text?: {
+        format: {
+            type: "json_object";
+        } | {
+            type: "json_schema";
+            name: string;
+            schema: Record<string, unknown>;
+            description?: string | undefined;
+            strict?: boolean | undefined;
+        };
+    } | null | undefined;
+    previous_response_id?: string | null | undefined;
+    conversation_id?: string | null | undefined;
+    providerOptions?: {
+        [x: string]: unknown;
+        openai?: Record<string, unknown> | undefined;
+    } | undefined;
+    tools?: {
+        type: "function";
+        name: string;
+        description?: string | undefined;
+        parameters?: unknown;
+    }[] | undefined;
+    store?: boolean | undefined;
+}, "datastream-response", import("../server-adapter").RouteSchemas<undefined, undefined, import("zod").ZodObject<{
+    model: import("zod").ZodString;
+    agent_id: import("zod").ZodOptional<import("zod").ZodString>;
+    input: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodObject<{
+        role: import("zod").ZodEnum<{
+            system: "system";
+            user: "user";
+            assistant: "assistant";
+            developer: "developer";
+        }>;
+        content: import("zod").ZodUnion<readonly [import("zod").ZodString, import("zod").ZodArray<import("zod").ZodObject<{
+            type: import("zod").ZodEnum<{
+                text: "text";
+                input_text: "input_text";
+                output_text: "output_text";
+            }>;
+            text: import("zod").ZodString;
+        }, import("zod/v4/core").$strip>>]>;
+    }, import("zod/v4/core").$strip>>]>;
+    instructions: import("zod").ZodOptional<import("zod").ZodString>;
+    text: import("zod").ZodOptional<import("zod").ZodObject<{
+        format: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"json_object">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"json_schema">;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            schema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>]>;
+    }, import("zod/v4/core").$strip>>;
+    conversation_id: import("zod").ZodOptional<import("zod").ZodString>;
+    providerOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+        openai: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$loose>>;
+    stream: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    store: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    previous_response_id: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$loose>, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    object: import("zod").ZodLiteral<"response">;
+    created_at: import("zod").ZodNumber;
+    completed_at: import("zod").ZodNullable<import("zod").ZodNumber>;
+    model: import("zod").ZodString;
+    status: import("zod").ZodEnum<{
+        completed: "completed";
+        in_progress: "in_progress";
+        incomplete: "incomplete";
+    }>;
+    output: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"message">;
+        role: import("zod").ZodLiteral<"assistant">;
+        status: import("zod").ZodEnum<{
+            completed: "completed";
+            in_progress: "in_progress";
+            incomplete: "incomplete";
+        }>;
+        content: import("zod").ZodArray<import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"output_text">;
+            text: import("zod").ZodString;
+            annotations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
+            logprobs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"function_call">;
+        call_id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        arguments: import("zod").ZodString;
+        status: import("zod").ZodOptional<import("zod").ZodEnum<{
+            completed: "completed";
+            in_progress: "in_progress";
+            incomplete: "incomplete";
+        }>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"function_call_output">;
+        call_id: import("zod").ZodString;
+        output: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>]>>;
+    usage: import("zod").ZodNullable<import("zod").ZodObject<{
+        input_tokens: import("zod").ZodNumber;
+        output_tokens: import("zod").ZodNumber;
+        total_tokens: import("zod").ZodNumber;
+        input_tokens_details: import("zod").ZodOptional<import("zod").ZodObject<{
+            cached_tokens: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+        output_tokens_details: import("zod").ZodOptional<import("zod").ZodObject<{
+            reasoning_tokens: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    error: import("zod").ZodOptional<import("zod").ZodNull>;
+    incomplete_details: import("zod").ZodOptional<import("zod").ZodNull>;
+    instructions: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    text: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
+        format: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"json_object">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"json_schema">;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            schema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>]>;
+    }, import("zod/v4/core").$strip>>>;
+    previous_response_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    conversation_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    providerOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+        openai: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$loose>>;
+    tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"function">;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>>>;
+    store: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>, "POST", "/v1/responses">;
+export declare const GET_RESPONSE_ROUTE: import("../server-adapter").ServerRoute<{
+    responseId: string;
+}, {
+    id: string;
+    object: "response";
+    created_at: number;
+    completed_at: number | null;
+    model: string;
+    status: "completed" | "in_progress" | "incomplete";
+    output: ({
+        id: string;
+        type: "message";
+        role: "assistant";
+        status: "completed" | "in_progress" | "incomplete";
+        content: {
+            type: "output_text";
+            text: string;
+            annotations?: unknown[] | undefined;
+            logprobs?: unknown[] | undefined;
+        }[];
+    } | {
+        id: string;
+        type: "function_call";
+        call_id: string;
+        name: string;
+        arguments: string;
+        status?: "completed" | "in_progress" | "incomplete" | undefined;
+    } | {
+        id: string;
+        type: "function_call_output";
+        call_id: string;
+        output: string;
+    })[];
+    usage: {
+        input_tokens: number;
+        output_tokens: number;
+        total_tokens: number;
+        input_tokens_details?: {
+            cached_tokens: number;
+        } | undefined;
+        output_tokens_details?: {
+            reasoning_tokens: number;
+        } | undefined;
+    } | null;
+    error?: null | undefined;
+    incomplete_details?: null | undefined;
+    instructions?: string | null | undefined;
+    text?: {
+        format: {
+            type: "json_object";
+        } | {
+            type: "json_schema";
+            name: string;
+            schema: Record<string, unknown>;
+            description?: string | undefined;
+            strict?: boolean | undefined;
+        };
+    } | null | undefined;
+    previous_response_id?: string | null | undefined;
+    conversation_id?: string | null | undefined;
+    providerOptions?: {
+        [x: string]: unknown;
+        openai?: Record<string, unknown> | undefined;
+    } | undefined;
+    tools?: {
+        type: "function";
+        name: string;
+        description?: string | undefined;
+        parameters?: unknown;
+    }[] | undefined;
+    store?: boolean | undefined;
+}, "json", import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
+    responseId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    object: import("zod").ZodLiteral<"response">;
+    created_at: import("zod").ZodNumber;
+    completed_at: import("zod").ZodNullable<import("zod").ZodNumber>;
+    model: import("zod").ZodString;
+    status: import("zod").ZodEnum<{
+        completed: "completed";
+        in_progress: "in_progress";
+        incomplete: "incomplete";
+    }>;
+    output: import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"message">;
+        role: import("zod").ZodLiteral<"assistant">;
+        status: import("zod").ZodEnum<{
+            completed: "completed";
+            in_progress: "in_progress";
+            incomplete: "incomplete";
+        }>;
+        content: import("zod").ZodArray<import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"output_text">;
+            text: import("zod").ZodString;
+            annotations: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
+            logprobs: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodUnknown>>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"function_call">;
+        call_id: import("zod").ZodString;
+        name: import("zod").ZodString;
+        arguments: import("zod").ZodString;
+        status: import("zod").ZodOptional<import("zod").ZodEnum<{
+            completed: "completed";
+            in_progress: "in_progress";
+            incomplete: "incomplete";
+        }>>;
+    }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+        id: import("zod").ZodString;
+        type: import("zod").ZodLiteral<"function_call_output">;
+        call_id: import("zod").ZodString;
+        output: import("zod").ZodString;
+    }, import("zod/v4/core").$strip>]>>;
+    usage: import("zod").ZodNullable<import("zod").ZodObject<{
+        input_tokens: import("zod").ZodNumber;
+        output_tokens: import("zod").ZodNumber;
+        total_tokens: import("zod").ZodNumber;
+        input_tokens_details: import("zod").ZodOptional<import("zod").ZodObject<{
+            cached_tokens: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+        output_tokens_details: import("zod").ZodOptional<import("zod").ZodObject<{
+            reasoning_tokens: import("zod").ZodNumber;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    error: import("zod").ZodOptional<import("zod").ZodNull>;
+    incomplete_details: import("zod").ZodOptional<import("zod").ZodNull>;
+    instructions: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    text: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodObject<{
+        format: import("zod").ZodUnion<readonly [import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"json_object">;
+        }, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+            type: import("zod").ZodLiteral<"json_schema">;
+            name: import("zod").ZodString;
+            description: import("zod").ZodOptional<import("zod").ZodString>;
+            schema: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>;
+            strict: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        }, import("zod/v4/core").$strip>]>;
+    }, import("zod/v4/core").$strip>>>;
+    previous_response_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    conversation_id: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    providerOptions: import("zod").ZodOptional<import("zod").ZodObject<{
+        openai: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+    }, import("zod/v4/core").$loose>>;
+    tools: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
+        type: import("zod").ZodLiteral<"function">;
+        name: import("zod").ZodString;
+        description: import("zod").ZodOptional<import("zod").ZodString>;
+        parameters: import("zod").ZodOptional<import("zod").ZodUnknown>;
+    }, import("zod/v4/core").$strip>>>;
+    store: import("zod").ZodOptional<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>, "GET", "/v1/responses/:responseId">;
+export declare const DELETE_RESPONSE_ROUTE: import("../server-adapter").ServerRoute<{
+    responseId: string;
+}, {
+    id: string;
+    object: "response";
+    deleted: true;
+}, "json", import("../server-adapter").RouteSchemas<import("zod").ZodObject<{
+    responseId: import("zod").ZodString;
+}, import("zod/v4/core").$strip>, undefined, undefined, import("zod").ZodObject<{
+    id: import("zod").ZodString;
+    object: import("zod").ZodLiteral<"response">;
+    deleted: import("zod").ZodLiteral<true>;
+}, import("zod/v4/core").$strip>>, "DELETE", "/v1/responses/:responseId">;
+//# sourceMappingURL=responses.d.ts.map

package/dist/server/handlers/responses.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"responses.d.ts","sourceRoot":"","sources":["../../../src/server/handlers/responses.ts"],"names":[],"mappings":"AA+yBA,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2DA8FhC,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;sEAuB7B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;yEA6BhC,CAAC"}

package/dist/server/handlers/responses.js

@@ -0,0 +1,3 @@
+export { CREATE_RESPONSE_ROUTE, DELETE_RESPONSE_ROUTE, GET_RESPONSE_ROUTE } from '../../chunk-VGHQI3X3.js';
+//# sourceMappingURL=responses.js.map
+//# sourceMappingURL=responses.js.map

package/dist/server/handlers/responses.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"responses.js"}

package/dist/server/handlers/responses.storage.cjs

@@ -0,0 +1,28 @@
+'use strict';
+
+var chunkB6HNPO67_cjs = require('../../chunk-B6HNPO67.cjs');
+
+
+
+Object.defineProperty(exports, "deleteResponseTurnRecord", {
+  enumerable: true,
+  get: function () { return chunkB6HNPO67_cjs.deleteResponseTurnRecord; }
+});
+Object.defineProperty(exports, "findResponseTurnRecord", {
+  enumerable: true,
+  get: function () { return chunkB6HNPO67_cjs.findResponseTurnRecord; }
+});
+Object.defineProperty(exports, "getResponseMemoryStore", {
+  enumerable: true,
+  get: function () { return chunkB6HNPO67_cjs.getResponseMemoryStore; }
+});
+Object.defineProperty(exports, "persistResponseTurnRecord", {
+  enumerable: true,
+  get: function () { return chunkB6HNPO67_cjs.persistResponseTurnRecord; }
+});
+Object.defineProperty(exports, "resolveResponseTurnMessagesForStorage", {
+  enumerable: true,
+  get: function () { return chunkB6HNPO67_cjs.resolveResponseTurnMessagesForStorage; }
+});
+//# sourceMappingURL=responses.storage.cjs.map
+//# sourceMappingURL=responses.storage.cjs.map

package/dist/server/handlers/responses.storage.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"responses.storage.cjs"}

package/dist/server/handlers/responses.storage.d.ts

@@ -0,0 +1,97 @@
+import type { MastraDBMessage } from '@mastra/core/agent';
+import type { Mastra } from '@mastra/core/mastra';
+import type { StorageThreadType } from '@mastra/core/memory';
+import type { RequestContext } from '@mastra/core/request-context';
+import type { MemoryStorage } from '@mastra/core/storage';
+import type { ResponseObject, ResponseTextConfig, ResponseTool, ResponseUsage } from '../schemas/responses.js';
+export type ThreadExecutionContext = {
+    threadId: string;
+    resourceId: string;
+};
+export type UsageLike = {
+    inputTokens?: number;
+    outputTokens?: number;
+    totalTokens?: number;
+    promptTokens?: number;
+    completionTokens?: number;
+} | null;
+export type ProviderMetadataLike = Record<string, Record<string, unknown> | undefined> | undefined;
+export type ResponseTurnRecordMetadata = {
+    agentId: string;
+    model: string;
+    createdAt: number;
+    completedAt: number | null;
+    status: ResponseObject['status'];
+    usage: ResponseUsage | null;
+    instructions?: string;
+    text?: ResponseTextConfig;
+    previousResponseId?: string;
+    providerOptions?: ProviderMetadataLike;
+    tools: ResponseTool[];
+    store: boolean;
+    messageIds: string[];
+};
+export type ResponseTurnRecord = {
+    metadata: ResponseTurnRecordMetadata;
+    message: MastraDBMessage;
+    messages: MastraDBMessage[];
+    thread: StorageThreadType;
+    memoryStore: MemoryStorage;
+};
+type ResponseResultLike = {
+    response?: Promise<{
+        dbMessages?: MastraDBMessage[];
+    }> | {
+        dbMessages?: MastraDBMessage[];
+    };
+};
+/**
+ * Resolves the memory storage used by response-turn records.
+ */
+export declare function getResponseMemoryStore(mastra: Mastra | undefined): Promise<MemoryStorage | null>;
+/**
+ * Looks up a stored response-turn record by response id.
+ *
+ * Response ids are assistant message ids, so this reconstructs the record by
+ * loading that persisted assistant message, reading its response metadata, then
+ * reloading the full set of stored turn messages referenced by the metadata.
+ */
+export declare function findResponseTurnRecord({ mastra, responseId, requestContext, }: {
+    mastra: Mastra | undefined;
+    responseId: string;
+    requestContext: RequestContext;
+}): Promise<ResponseTurnRecord | null>;
+/**
+ * Resolves the Mastra messages that belong to the response turn being stored.
+ */
+export declare function resolveResponseTurnMessagesForStorage({ result, responseId, text, threadContext, }: {
+    result: ResponseResultLike;
+    responseId: string;
+    text: string;
+    threadContext: ThreadExecutionContext | null;
+}): Promise<MastraDBMessage[]>;
+/**
+ * Persists a response-turn record by anchoring it on the final assistant
+ * message in the stored turn.
+ *
+ * The response id becomes that assistant message id, and the response-specific
+ * metadata is written onto the assistant message so later retrieval can rebuild
+ * the Responses object from thread-backed storage.
+ */
+export declare function persistResponseTurnRecord({ mastra, responseId, metadata, threadContext, messages, }: {
+    mastra: Mastra | undefined;
+    responseId: string;
+    metadata: ResponseTurnRecordMetadata;
+    threadContext: ThreadExecutionContext;
+    messages: MastraDBMessage[];
+}): Promise<void>;
+/**
+ * Removes all persisted messages for a stored response-turn record.
+ */
+export declare function deleteResponseTurnRecord({ mastra, responseId, requestContext, }: {
+    mastra: Mastra | undefined;
+    responseId: string;
+    requestContext: RequestContext;
+}): Promise<boolean>;
+export {};
+//# sourceMappingURL=responses.storage.d.ts.map