@agent-harness-experimental/adapter-mastra 0.0.0 → 0.0.1

package/dist/bridge.mts

@@ -0,0 +1,705 @@
+#!/usr/bin/env node
+import {
+  consumeCompactRequest,
+  drainUserMessages,
+  emit,
+  finish,
+  initBridge,
+  requestPrepareStep,
+  requestToolResult,
+  setRunning,
+  waitForNextPrompt,
+  waitForStart,
+} from './bridge-ws-server.mts';
+import { createDelegateToolDescription } from './bridge-delegation.mts';
+import { filterToolMap, filterToolSchemas, isToolAllowed } from './bridge-tool-policy.mts';
+import type { BridgeToolSchema } from './bridge-tool-policy.mts';
+import { parseJsonWithSchema } from './bridge-parse.mts';
+import { applyBridgeContinuationConfig } from './bridge-continuation.mts';
+import { renderBridgeSkillBlock, renderBridgeSubagentBlock } from './bridge-prompt-blocks.mts';
+import { exec as execCallback } from 'node:child_process';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { randomUUID } from 'node:crypto';
+import { isAbsolute, join, relative, resolve } from 'node:path';
+import { promisify } from 'node:util';
+import { z } from 'zod';
+import { msg as protocolMessage } from '@agent-harness-experimental/protocol';
+
+type SkillDefinition = {
+  name: string;
+  description: string;
+  content: string;
+};
+
+type AgentDefinition = {
+  description: string;
+  prompt: string;
+  model?: string;
+  tools?: string[];
+  maxTurns?: number;
+};
+
+type BuiltinToolMapping = {
+  name: string;
+  nativeName?: string;
+};
+
+type BridgeResponseFormat =
+  | { type: 'text' }
+  | {
+      type: 'json';
+      schema?: Record<string, unknown>;
+      name?: string;
+      description?: string;
+    };
+
+type MastraBridgeConfig = {
+  workDir?: string;
+  model?: string;
+  provider?: 'anthropic' | 'openai';
+  maxTurns?: number;
+  instructions?: string;
+  responseFormat?: BridgeResponseFormat;
+  skills?: SkillDefinition[];
+  activeSkillNames?: string[];
+  forcedSkillNames?: string[];
+  activeTools?: string[];
+  agents?: Record<string, AgentDefinition>;
+  builtinToolMappings?: BuiltinToolMapping[];
+};
+
+type ConversationMessage = {
+  role: 'user' | 'assistant';
+  content: string;
+};
+
+const conversationMessageSchema = z.object({
+  role: z.enum(['user', 'assistant']),
+  content: z.string(),
+});
+
+const mastraStreamChunkSchema = z.discriminatedUnion('type', [
+  z.object({ type: z.literal('text-delta'), payload: z.object({ text: z.string() }).passthrough() }).passthrough(),
+  z.object({ type: z.literal('reasoning-delta'), payload: z.object({ text: z.string() }).passthrough() }).passthrough(),
+  z
+    .object({
+      type: z.literal('tool-call'),
+      payload: z.object({ toolName: z.string(), toolCallId: z.string(), args: z.unknown() }).passthrough(),
+    })
+    .passthrough(),
+  z
+    .object({
+      type: z.literal('tool-result'),
+      payload: z.object({ toolName: z.string(), toolCallId: z.string(), result: z.unknown() }).passthrough(),
+    })
+    .passthrough(),
+  z.object({ type: z.literal('tool-error'), payload: z.object({ toolName: z.string(), error: z.unknown() }).passthrough() }).passthrough(),
+  z.object({ type: z.literal('error'), payload: z.object({ error: z.unknown() }).passthrough() }).passthrough(),
+]);
+
+type MastraStreamChunk = z.infer<typeof mastraStreamChunkSchema>;
+
+function parseNativeEvent(raw: unknown): MastraStreamChunk | null {
+  const parsed = mastraStreamChunkSchema.safeParse(raw);
+  return parsed.success ? parsed.data : null;
+}
+
+type JsonSchemaObject = {
+  type?: string;
+  description?: string;
+  properties?: Record<string, unknown>;
+  required?: string[];
+  items?: unknown;
+};
+
+type LocalToolDefinition<INPUT> = {
+  description: string;
+  inputSchema: z.ZodType<INPUT>;
+  execute(input: INPUT, context?: { toolCallId?: string }): Promise<unknown> | unknown;
+};
+
+function tool<INPUT>(definition: LocalToolDefinition<INPUT>): LocalToolDefinition<INPUT> {
+  return definition;
+}
+
+type ModelRouterId = `${string}/${string}`;
+
+type MastraRunOptions = {
+  prompt: string;
+  toolSchemas: BridgeToolSchema[];
+  config: MastraBridgeConfig;
+  history?: ConversationMessage[];
+  emitText?: boolean;
+  allowDelegation?: boolean;
+  subagent?: {
+    name: string;
+    definition: AgentDefinition;
+  };
+};
+
+process.on('uncaughtException', (error) => {
+  emit(protocolMessage.error({ message: `Bridge crash: ${error.message}\n${error.stack}` }));
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (error) => {
+  emit(protocolMessage.error({ message: `Bridge rejection: ${error instanceof Error ? error.message : String(error)}` }));
+  process.exit(1);
+});
+
+initBridge();
+
+process.env.PATH = `/tmp/node_modules/.bin:${process.env.PATH || ''}`;
+process.env.MASTRA_OFFLINE = process.env.MASTRA_OFFLINE || 'true';
+process.env.MASTRA_TELEMETRY_DISABLED = process.env.MASTRA_TELEMETRY_DISABLED || 'true';
+
+const HISTORY_PATH = join(process.cwd(), '.mastra-history.json');
+const MAX_COMPACT_HISTORY_MESSAGES = 12;
+const execAsync = promisify(execCallback);
+
+function loadHistory(): ConversationMessage[] {
+  if (!existsSync(HISTORY_PATH)) {
+    return [];
+  }
+
+  try {
+    return parseJsonWithSchema(z.array(conversationMessageSchema), readFileSync(HISTORY_PATH, 'utf8'));
+  } catch {
+    return [];
+  }
+}
+
+function saveHistory(history: ConversationMessage[]) {
+  writeFileSync(HISTORY_PATH, JSON.stringify(history, null, 2));
+}
+
+function compactHistory(history: ConversationMessage[]): ConversationMessage[] {
+  if (history.length <= MAX_COMPACT_HISTORY_MESSAGES) {
+    return history;
+  }
+
+  return history.slice(-MAX_COMPACT_HISTORY_MESSAGES);
+}
+
+function parseModel(model: string | undefined, provider: MastraBridgeConfig['provider']) {
+  const rawModel = model || 'anthropic/claude-sonnet-4';
+  if (rawModel.includes('/')) {
+    const [rawProvider, ...modelParts] = rawModel.split('/');
+    const modelId = modelParts.join('/');
+    if (rawProvider === 'anthropic' || rawProvider === 'openai') {
+      return {
+        provider: provider || rawProvider,
+        modelId,
+      };
+    }
+  }
+
+  return {
+    provider: provider || 'anthropic',
+    modelId: rawModel,
+  };
+}
+
+function toZodSchema(schema: unknown): z.ZodTypeAny {
+  const jsonSchema = (typeof schema === 'object' && schema !== null ? schema : {}) as JsonSchemaObject;
+  const type = jsonSchema.type;
+
+  switch (type) {
+    case 'string':
+      return z.string();
+    case 'number':
+      return z.number();
+    case 'integer':
+      return z.number().int();
+    case 'boolean':
+      return z.boolean();
+    case 'array':
+      return z.array(toZodSchema(jsonSchema.items));
+    case 'object': {
+      const props = jsonSchema.properties ?? {};
+      const required = new Set(jsonSchema.required ?? []);
+      const shape: Record<string, z.ZodTypeAny> = {};
+      for (const [key, value] of Object.entries(props)) {
+        const propSchema = value as JsonSchemaObject;
+        let zodSchema = toZodSchema(propSchema);
+        if (typeof propSchema.description === 'string' && propSchema.description.length > 0) {
+          zodSchema = zodSchema.describe(propSchema.description);
+        }
+        shape[key] = required.has(key) ? zodSchema : zodSchema.optional();
+      }
+      return z.object(shape).passthrough();
+    }
+    default:
+      return z.any();
+  }
+}
+
+function renderSkillsBlock(skills: SkillDefinition[] | undefined, activeSkillNames?: string[]) {
+  return renderBridgeSkillBlock(skills, activeSkillNames, {
+    heading: '## Available Skills',
+    renderSkill: (skill) => `### ${skill.name}\n${skill.description}\n\n${skill.content}`,
+  });
+}
+
+function renderSubagentBlock(agents: Record<string, AgentDefinition> | undefined) {
+  return renderBridgeSubagentBlock(agents, {
+    heading: '## Available Subagents',
+    intro: 'Use the `delegate_task` tool when a specialized worker is a better fit than continuing in the main agent.',
+    renderAgent: (name, definition) =>
+      `### ${name}\n${definition.description}\n\nPrompt: ${definition.prompt}${definition.model ? `\nModel: ${definition.model}` : ''}${definition.tools?.length ? `\nTools: ${definition.tools.join(', ')}` : ''}${definition.maxTurns ? `\nMax turns: ${definition.maxTurns}` : ''}`,
+  });
+}
+
+function buildInstructions(config: MastraBridgeConfig, subagent?: { name: string; definition: AgentDefinition }, allowedTools?: string[]) {
+  const sections = [
+    'You are a helpful assistant with access to workspace tools.',
+    'When the user asks about a local file, use the available file tool instead of claiming you cannot access files.',
+    config.instructions ?? '',
+    renderSkillsBlock(config.skills, config.activeSkillNames),
+  ];
+
+  if (subagent) {
+    sections.push(`You are the subagent "${subagent.name}".`);
+    sections.push(subagent.definition.prompt);
+    if (allowedTools?.length) {
+      sections.push(`Only use these tools for this delegated task: ${allowedTools.join(', ')}.`);
+    }
+  } else {
+    sections.push(renderSubagentBlock(config.agents));
+  }
+
+  return sections.filter(Boolean).join('\n\n');
+}
+
+function guardToolMapWithActiveTools<TOOLS extends Record<string, unknown>>(tools: TOOLS, getActiveTools: () => string[] | undefined): TOOLS {
+  return Object.fromEntries(
+    Object.entries(tools).map(([name, candidate]) => {
+      if (typeof candidate !== 'object' || candidate === null || !('execute' in candidate) || typeof candidate.execute !== 'function') {
+        return [name, candidate];
+      }
+
+      const executable = candidate as { execute: (...args: unknown[]) => unknown };
+      return [
+        name,
+        {
+          ...candidate,
+          async execute(...args: unknown[]) {
+            if (!isToolAllowed(name, getActiveTools())) {
+              return {
+                type: 'execution-denied',
+                reason: `Tool "${name}" is blocked by activeTools`,
+              };
+            }
+            return await executable.execute(...args);
+          },
+        },
+      ];
+    }),
+  ) as TOOLS;
+}
+
+function applyBuiltinToolAliases<TOOLS extends Record<string, unknown>>(tools: TOOLS, mappings?: BuiltinToolMapping[]) {
+  if (!mappings?.length) {
+    return tools;
+  }
+
+  const aliasedTools: Record<string, unknown> = { ...tools };
+  for (const mapping of mappings) {
+    if (!mapping.nativeName || mapping.nativeName === mapping.name) {
+      continue;
+    }
+
+    const canonicalTool = aliasedTools[mapping.name];
+    if (canonicalTool !== undefined && aliasedTools[mapping.nativeName] === undefined) {
+      aliasedTools[mapping.nativeName] = canonicalTool;
+    }
+  }
+
+  return aliasedTools as TOOLS;
+}
+
+function createStructuredOutput(responseFormat: BridgeResponseFormat | undefined) {
+  if (!responseFormat || responseFormat.type !== 'json' || !responseFormat.schema) {
+    return undefined;
+  }
+
+  return {
+    schema: responseFormat.schema,
+  };
+}
+
+async function createModel(config: MastraBridgeConfig) {
+  const { provider, modelId } = parseModel(config.model, config.provider);
+  const gatewayKey = process.env.AI_GATEWAY_API_KEY;
+
+  if (gatewayKey) {
+    return `vercel/${provider}/${modelId}`;
+  }
+
+  if (provider === 'openai' && process.env.OPENAI_BASE_URL) {
+    const id = `${process.env.OPENAI_NAME || 'openai'}/${modelId}` as ModelRouterId;
+    return {
+      id,
+      url: process.env.OPENAI_BASE_URL,
+      apiKey: process.env.OPENAI_API_KEY,
+    };
+  }
+
+  return `${provider}/${modelId}`;
+}
+
+async function createHarnessTools(toolSchemas: BridgeToolSchema[]) {
+  return Object.fromEntries(
+    toolSchemas.map((schema) => [
+      schema.name,
+      tool({
+        description: schema.description ?? '',
+        inputSchema: toZodSchema(schema.inputSchema),
+        async execute(input: unknown) {
+          const requestId = randomUUID();
+          emit(protocolMessage.toolCall({ requestId, toolName: schema.name, toolCallId: requestId, input }));
+          const response = await requestToolResult(requestId);
+          const result = response.output;
+          emit(protocolMessage.toolResult({ toolName: schema.name, toolCallId: requestId, output: result }));
+          return result;
+        },
+      }),
+    ]),
+  );
+}
+
+async function createBuiltinTools(workDir: string) {
+  const resolveWorkspacePath = (inputPath: string, description: string) => {
+    if (inputPath.includes('\0')) {
+      throw new Error(`${description} contains a NUL byte`);
+    }
+    if (isAbsolute(inputPath)) {
+      throw new Error(`${description} must be relative to the workspace`);
+    }
+    const root = resolve(workDir);
+    const filePath = resolve(root, inputPath);
+    const relativePath = relative(root, filePath);
+    if (relativePath.startsWith('..') || isAbsolute(relativePath)) {
+      throw new Error(`${description} escapes the workspace`);
+    }
+    return {
+      filePath,
+      relativePath: relativePath || '.',
+    };
+  };
+
+  return {
+    read: tool({
+      description: 'Read a UTF-8 text file from the current workspace using a relative path.',
+      inputSchema: z.object({
+        path: z.string().describe('Relative path to the file inside the workspace'),
+      }),
+      async execute(input) {
+        const { filePath, relativePath } = resolveWorkspacePath(input.path, 'read path');
+        const fileStat = await stat(filePath);
+        if (fileStat.isDirectory()) {
+          const entries = await readdir(filePath);
+          return { path: relativePath, entries };
+        }
+        const content = await readFile(filePath, 'utf8');
+        return { path: relativePath, content };
+      },
+    }),
+    exec_command: tool({
+      description: 'Execute a shell command in the workspace.',
+      inputSchema: z
+        .object({
+          cmd: z.string().optional().describe('Command to execute'),
+          command: z.string().optional().describe('Command to execute'),
+          workdir: z.string().optional().describe('Optional working directory relative to the workspace'),
+        })
+        .passthrough(),
+      async execute(input) {
+        const command = input.cmd ?? input.command;
+        if (!command) {
+          throw new Error('exec_command requires cmd or command');
+        }
+        const cwd = input.workdir ? resolveWorkspacePath(input.workdir, 'exec_command workdir').filePath : workDir;
+        try {
+          const { stdout, stderr } = await execAsync(command, {
+            cwd,
+            env: process.env,
+            maxBuffer: 1024 * 1024,
+          });
+          return {
+            exitCode: 0,
+            command,
+            stdout,
+            stderr,
+            output: `${stdout}${stderr}`,
+          };
+        } catch (error) {
+          const err = error as { code?: number; stdout?: string; stderr?: string; message?: string };
+          return {
+            exitCode: typeof err.code === 'number' ? err.code : 1,
+            command,
+            stdout: typeof err.stdout === 'string' ? err.stdout : '',
+            stderr: typeof err.stderr === 'string' ? err.stderr : (err.message ?? ''),
+            output: `${typeof err.stdout === 'string' ? err.stdout : ''}${typeof err.stderr === 'string' ? err.stderr : (err.message ?? '')}`,
+          };
+        }
+      },
+    }),
+  };
+}
+
+async function runMastraTurn({ prompt, toolSchemas, config, history = [], emitText = true, allowDelegation = true, subagent }: MastraRunOptions) {
+  const mastraWorkDir = config.workDir ?? process.cwd();
+  const [{ Agent }, harnessTools, builtinTools] = await Promise.all([
+    import('@mastra/core/agent'),
+    createHarnessTools(toolSchemas),
+    createBuiltinTools(mastraWorkDir),
+  ]);
+
+  const availableTools = applyBuiltinToolAliases(
+    filterToolMap(
+      {
+        ...builtinTools,
+        ...harnessTools,
+      },
+      subagent?.definition.tools,
+    ),
+    config.builtinToolMappings,
+  );
+  const allowedToolNames = subagent?.definition.tools?.length ? Object.keys(availableTools) : undefined;
+  const model = await createModel({
+    ...config,
+    ...(subagent?.definition.model ? { model: subagent.definition.model } : {}),
+  });
+
+  let delegateTools: Record<string, unknown> = {};
+  if (allowDelegation && config.agents && Object.keys(config.agents).length > 0 && !subagent) {
+    const agentNames = Object.keys(config.agents);
+    const [firstAgent, ...restAgents] = agentNames;
+    if (firstAgent) {
+      const agentSchema = restAgents.length === 0 ? z.literal(firstAgent) : z.enum([firstAgent, ...restAgents] as [string, ...string[]]);
+      delegateTools = {
+        delegate_task: tool({
+          description: createDelegateToolDescription(config.agents),
+          inputSchema: z.object({
+            agent: agentSchema.describe('Subagent to run'),
+            task: z.string().min(1).describe('Focused task for the delegated subagent'),
+          }),
+          async execute(input, context?: { toolCallId?: string }) {
+            const definition = config.agents?.[input.agent];
+            if (!definition) {
+              throw new Error(`Unknown subagent: ${input.agent}`);
+            }
+
+            const parentToolCallId = context?.toolCallId;
+            if (parentToolCallId) {
+              emit(protocolMessage.subagentStart({ agentName: input.agent, parentToolCallId }));
+            }
+
+            let result: Awaited<ReturnType<typeof runMastraTurn>> | null = null;
+            try {
+              result = await runMastraTurn({
+                prompt: input.task,
+                toolSchemas: filterToolSchemas(toolSchemas, definition.tools),
+                config,
+                emitText: false,
+                allowDelegation: false,
+                subagent: {
+                  name: input.agent,
+                  definition,
+                },
+              });
+            } finally {
+              if (parentToolCallId) {
+                emit(
+                  protocolMessage.subagentFinish({
+                    agentName: input.agent,
+                    parentToolCallId,
+                    ...(result ? { output: { agent: input.agent, text: result.text } } : {}),
+                    ...(result?.usage ? { usage: result.usage } : {}),
+                  }),
+                );
+              }
+            }
+
+            if (!result) {
+              throw new Error(`Subagent ${input.agent} did not produce a result`);
+            }
+
+            return {
+              agent: input.agent,
+              text: result.text,
+            };
+          },
+        }),
+      };
+    }
+  }
+
+  const unguardedTools = {
+    ...availableTools,
+    ...delegateTools,
+  };
+  let currentActiveTools = allowedToolNames?.length ? allowedToolNames : config.activeTools?.length ? config.activeTools : undefined;
+  const tools = subagent ? unguardedTools : guardToolMapWithActiveTools(unguardedTools, () => currentActiveTools);
+
+  const messages = [...history, { role: 'user' as const, content: prompt }];
+  const userToolNames = new Set(toolSchemas.map((schema) => schema.name));
+  const structuredOutput = subagent ? undefined : createStructuredOutput(config.responseFormat);
+  const agent = new Agent({
+    id: subagent ? `subagent-${subagent.name}` : 'sandbox-agent',
+    name: subagent ? `Subagent ${subagent.name}` : 'Sandbox Agent',
+    instructions: buildInstructions(config, subagent, allowedToolNames),
+    model,
+    tools,
+  });
+
+  const streamOptions = {
+    maxSteps: subagent?.definition.maxTurns ?? config.maxTurns ?? 5,
+    ...(structuredOutput ? { structuredOutput: structuredOutput as never } : {}),
+    ...(!subagent
+      ? {
+          prepareStep: async ({ stepNumber }: { stepNumber: number }) => {
+            if (stepNumber === 0) {
+              return undefined;
+            }
+
+            const next = await requestPrepareStep(stepNumber);
+            if (Object.hasOwn(next, 'activeTools')) {
+              currentActiveTools = next.activeTools;
+            }
+            const nextConfig: MastraBridgeConfig = {
+              ...config,
+            };
+            applyBridgeContinuationConfig(nextConfig, next, ['instructions', 'activeTools', 'activeSkillNames', 'forcedSkillNames'], {
+              emptyArrayKeys: ['activeSkillNames', 'forcedSkillNames'],
+            });
+
+            return {
+              system: buildInstructions(nextConfig),
+            };
+          },
+        }
+      : {}),
+  } as never;
+
+  const result = await agent.stream(messages, streamOptions);
+
+  let assistantText = '';
+
+  for await (const rawChunk of result.fullStream as AsyncIterable<unknown>) {
+    const chunk = parseNativeEvent(rawChunk);
+    if (!chunk) {
+      continue;
+    }
+    switch (chunk.type) {
+      case 'text-delta':
+        assistantText += chunk.payload.text;
+        if (emitText) {
+          emit(protocolMessage.textDelta({ delta: chunk.payload.text }));
+        }
+        break;
+      case 'reasoning-delta':
+        if (emitText) {
+          emit(protocolMessage.reasoningDelta({ delta: chunk.payload.text }));
+        }
+        break;
+      case 'tool-call':
+        if (!userToolNames.has(chunk.payload.toolName)) {
+          emit(
+            protocolMessage.toolCall({
+              requestId: chunk.payload.toolCallId,
+              toolName: chunk.payload.toolName,
+              toolCallId: chunk.payload.toolCallId,
+              input: chunk.payload.args,
+              observeOnly: true,
+            }),
+          );
+        }
+        break;
+      case 'tool-result':
+        if (!userToolNames.has(chunk.payload.toolName)) {
+          emit(protocolMessage.toolResult({ toolName: chunk.payload.toolName, toolCallId: chunk.payload.toolCallId, output: chunk.payload.result }));
+        }
+        break;
+      case 'tool-error':
+      case 'error':
+        emit(
+          protocolMessage.error({
+            message:
+              chunk.type === 'tool-error'
+                ? `${chunk.payload.toolName}: ${chunk.payload.error instanceof Error ? chunk.payload.error.message : String(chunk.payload.error)}`
+                : chunk.payload.error instanceof Error
+                  ? chunk.payload.error.message
+                  : String(chunk.payload.error),
+          }),
+        );
+        break;
+    }
+  }
+
+  if (!assistantText) {
+    if (structuredOutput) {
+      const object = await (result as { object: Promise<unknown> }).object;
+      assistantText = JSON.stringify(object);
+      if (emitText && assistantText) {
+        emit(protocolMessage.textDelta({ delta: assistantText }));
+      }
+    } else {
+      assistantText = await result.text;
+    }
+  }
+
+  const [finishReason, usage] = await Promise.all([result.finishReason, result.usage]);
+
+  return {
+    text: assistantText,
+    finishReason: finishReason || 'stop',
+    usage: {
+      inputTokens: usage?.inputTokens ?? 0,
+      outputTokens: usage?.outputTokens ?? 0,
+    },
+  };
+}
+
+async function runTurn(prompt: string, toolSchemas: BridgeToolSchema[], config: MastraBridgeConfig, history: ConversationMessage[]) {
+  const result = await runMastraTurn({
+    prompt,
+    toolSchemas,
+    config,
+    history,
+  });
+
+  history.push({ role: 'user', content: prompt }, { role: 'assistant', content: result.text });
+  saveHistory(history);
+
+  emit(protocolMessage.finish({ finishReason: result.finishReason, usage: result.usage }));
+}
+
+let history = loadHistory();
+let { prompt, tools, config } = await waitForStart();
+setRunning();
+
+while (true) {
+  try {
+    await runTurn(prompt, tools, config as MastraBridgeConfig, history);
+  } catch (error) {
+    emit(protocolMessage.error({ message: error instanceof Error ? error.message : String(error) }));
+  }
+
+  await finish();
+
+  const next = await waitForNextPrompt();
+  const queuedMessages = drainUserMessages();
+  if (consumeCompactRequest()) {
+    history = compactHistory(history);
+    saveHistory(history);
+  }
+
+  prompt = queuedMessages.length > 0 ? `${queuedMessages.join('\n\n')}\n\n${next.prompt}` : next.prompt;
+  tools = next.tools;
+  config = next.config;
+  history = loadHistory();
+  setRunning();
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { mastra } from './adapter.js';
+export { MASTRA_SANDBOX_SETUP, MASTRA_SUPPORT_MATRIX_ROW, getMastraSandboxSetup } from './setup.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,oBAAoB,EAAE,yBAAyB,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC"}