@ai2070/l0/dist/adapters/mastra.js

L0: The Missing Reliability Substrate for AI

async function* wrapMastraStream(streamResult, options = {}) {
  const {
    includeUsage = true,
    includeToolCalls = true,
    includeReasoning = false
  } = options;
  try {
    const textStream = streamResult.textStream;
    for await (const value of textStream) {
      if (value) {
        yield {
          type: "token",
          value,
          timestamp: Date.now()
        };
      }
    }
    if (includeReasoning) {
      try {
        const reasoningText = await streamResult.reasoningText;
        if (reasoningText) {
          yield {
            type: "message",
            value: JSON.stringify({
              type: "reasoning",
              reasoning: reasoningText
            }),
            role: "assistant",
            timestamp: Date.now()
          };
        }
      } catch {
      }
    }
    if (includeToolCalls) {
      try {
        const toolCalls = await streamResult.toolCalls;
        if (toolCalls && toolCalls.length > 0) {
          yield {
            type: "message",
            value: JSON.stringify({
              type: "tool_calls",
              tool_calls: toolCalls.map((tc) => ({
                id: tc.payload?.toolCallId ?? tc.toolCallId,
                name: tc.payload?.toolName ?? tc.toolName,
                arguments: JSON.stringify(tc.payload?.args ?? tc.args)
              }))
            }),
            role: "assistant",
            timestamp: Date.now()
          };
        }
      } catch {
      }
      try {
        const toolResults = await streamResult.toolResults;
        if (toolResults && toolResults.length > 0) {
          yield {
            type: "message",
            value: JSON.stringify({
              type: "tool_results",
              tool_results: toolResults.map((tr) => ({
                id: tr.payload?.toolCallId ?? tr.toolCallId,
                name: tr.payload?.toolName ?? tr.toolName,
                result: tr.payload?.result ?? tr.result
              }))
            }),
            role: "assistant",
            timestamp: Date.now()
          };
        }
      } catch {
      }
    }
    let usage;
    let finishReason;
    if (includeUsage) {
      try {
        usage = await streamResult.usage;
      } catch {
      }
    }
    try {
      finishReason = await streamResult.finishReason;
    } catch {
    }
    yield {
      type: "complete",
      timestamp: Date.now(),
      ...includeUsage && usage ? { usage } : {},
      ...finishReason ? { finishReason } : {}
    };
  } catch (error) {
    yield {
      type: "error",
      error: error instanceof Error ? error : new Error(String(error)),
      timestamp: Date.now()
    };
  }
}
function mastraStream(agent, messages, streamOptions, adapterOptions) {
  return async () => {
    const streamResult = await agent.stream(messages, streamOptions);
    return wrapMastraStream(
      streamResult,
      adapterOptions
    );
  };
}
function mastraText(agent, prompt, options) {
  const { includeUsage, includeToolCalls, includeReasoning, ...streamOptions } = options || {};
  return mastraStream(agent, prompt, streamOptions, {
    includeUsage,
    includeToolCalls,
    includeReasoning
  });
}
function mastraStructured(agent, prompt, schema, options) {
  const { includeUsage, includeToolCalls, includeReasoning, ...streamOptions } = options || {};
  return mastraStream(
    agent,
    prompt,
    {
      ...streamOptions,
      structuredOutput: { schema }
    },
    { includeUsage, includeToolCalls, includeReasoning }
  );
}
async function* wrapMastraFullStream(streamResult, options = {}) {
  const {
    includeUsage = true,
    includeToolCalls = true,
    includeReasoning = false
  } = options;
  try {
    const fullStream = streamResult.fullStream;
    for await (const value of fullStream) {
      if (!value) continue;
      const chunk = value;
      switch (chunk.type) {
        case "text-delta":
          yield {
            type: "token",
            value: chunk.payload?.text ?? chunk.textDelta,
            timestamp: Date.now()
          };
          break;
        case "reasoning":
          if (includeReasoning) {
            yield {
              type: "message",
              value: JSON.stringify({
                type: "reasoning",
                reasoning: chunk.payload?.text ?? chunk.textDelta
              }),
              role: "assistant",
              timestamp: Date.now()
            };
          }
          break;
        case "tool-call":
          if (includeToolCalls) {
            const payload = chunk.payload ?? chunk;
            yield {
              type: "message",
              value: JSON.stringify({
                type: "tool_call",
                tool_call: {
                  id: payload.toolCallId,
                  name: payload.toolName,
                  arguments: JSON.stringify(payload.args)
                }
              }),
              role: "assistant",
              timestamp: Date.now()
            };
          }
          break;
        case "tool-result":
          if (includeToolCalls) {
            const payload = chunk.payload ?? chunk;
            yield {
              type: "message",
              value: JSON.stringify({
                type: "tool_result",
                tool_result: {
                  id: payload.toolCallId,
                  name: payload.toolName,
                  result: payload.result
                }
              }),
              role: "assistant",
              timestamp: Date.now()
            };
          }
          break;
        case "finish":
          let usage;
          if (includeUsage) {
            try {
              usage = await streamResult.usage;
            } catch {
            }
          }
          yield {
            type: "complete",
            timestamp: Date.now(),
            ...includeUsage && usage ? { usage } : {},
            ...chunk.finishReason ? { finishReason: chunk.finishReason } : {}
          };
          break;
        case "error":
          yield {
            type: "error",
            error: chunk.error instanceof Error ? chunk.error : new Error(String(chunk.error)),
            timestamp: Date.now()
          };
          break;
      }
    }
  } catch (error) {
    yield {
      type: "error",
      error: error instanceof Error ? error : new Error(String(error)),
      timestamp: Date.now()
    };
  }
}
function isMastraStream(obj) {
  if (!obj || typeof obj !== "object") {
    return false;
  }
  const stream = obj;
  return "textStream" in stream && "text" in stream && "usage" in stream && "finishReason" in stream && // Mastra-specific properties
  "runId" in stream && "messageList" in stream;
}
async function extractMastraText(streamResult) {
  return streamResult.text;
}
async function extractMastraObject(streamResult) {
  return streamResult.object;
}
const mastraAdapter = {
  name: "mastra",
  detect: isMastraStream,
  wrap: wrapMastraStream
};
import { registerAdapter } from "./registry";
try {
  registerAdapter(mastraAdapter, { silent: true });
} catch {
}
export {
  extractMastraObject,
  extractMastraText,
  isMastraStream,
  mastraAdapter,
  mastraStream,
  mastraStructured,
  mastraText,
  wrapMastraFullStream,
  wrapMastraStream
};
//# sourceMappingURL=mastra.js.map