@mastra/client-js 0.0.0-storage-20250225005900 → 0.0.0-support-d1-client-20250701191943

package/src/types.ts

@@ -1,16 +1,26 @@
 import type {
-  MessageType,
+  MastraMessageV1,
   AiMessageType,
   CoreMessage,
   QueryResult,
-  StepAction,
-  StepGraph,
   StorageThreadType,
-  BaseLogMessage,
-  OutputType,
+  WorkflowRuns,
+  WorkflowRun,
+  LegacyWorkflowRuns,
 } from '@mastra/core';
+import type { AgentGenerateOptions, AgentStreamOptions, ToolsInput } from '@mastra/core/agent';
+import type { BaseLogMessage, LogLevel } from '@mastra/core/logger';
+
+import type { MCPToolType, ServerInfo } from '@mastra/core/mcp';
+import type { RuntimeContext } from '@mastra/core/runtime-context';
+import type { Workflow, WatchEvent, WorkflowResult } from '@mastra/core/workflows';
+import type {
+  StepAction,
+  StepGraph,
+  LegacyWorkflowRunResult as CoreLegacyWorkflowRunResult,
+} from '@mastra/core/workflows/legacy';
 import type { JSONSchema7 } from 'json-schema';
-import { ZodSchema } from 'zod';
+import type { ZodSchema } from 'zod';
 
 export interface ClientOptions {
   /** Base URL for API requests */
@@ -23,6 +33,7 @@ export interface ClientOptions {
   maxBackoffMs?: number;
   /** Custom headers to include with requests */
   headers?: Record<string, string>;
+  /** Abort signal for request */
 }
 
 export interface RequestOptions {
@@ -30,31 +41,51 @@ export interface RequestOptions {
   headers?: Record<string, string>;
   body?: any;
   stream?: boolean;
+  signal?: AbortSignal;
 }
 
+type WithoutMethods<T> = {
+  [K in keyof T as T[K] extends (...args: any[]) => any
+    ? never
+    : T[K] extends { (): any }
+      ? never
+      : T[K] extends undefined | ((...args: any[]) => any)
+        ? never
+        : K]: T[K];
+};
+
 export interface GetAgentResponse {
   name: string;
   instructions: string;
   tools: Record<string, GetToolResponse>;
+  workflows: Record<string, GetWorkflowResponse>;
   provider: string;
+  modelId: string;
+  defaultGenerateOptions: WithoutMethods<AgentGenerateOptions>;
+  defaultStreamOptions: WithoutMethods<AgentStreamOptions>;
 }
 
-export interface GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-  messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
+export type GenerateParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+  messages: string | string[] | CoreMessage[] | AiMessageType[];
+  output?: T;
+  experimental_output?: T;
+  runtimeContext?: RuntimeContext | Record<string, any>;
+  clientTools?: ToolsInput;
+} & WithoutMethods<Omit<AgentGenerateOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools'>>;
 
-export interface StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> {
-  messages: string | string[] | CoreMessage[];
-  threadId?: string;
-  resourceid?: string;
-  output?: OutputType | T;
-}
+export type StreamParams<T extends JSONSchema7 | ZodSchema | undefined = undefined> = {
+  messages: string | string[] | CoreMessage[] | AiMessageType[];
+  output?: T;
+  experimental_output?: T;
+  runtimeContext?: RuntimeContext | Record<string, any>;
+  clientTools?: ToolsInput;
+} & WithoutMethods<Omit<AgentStreamOptions<T>, 'output' | 'experimental_output' | 'runtimeContext' | 'clientTools'>>;
 
 export interface GetEvalsByAgentIdResponse extends GetAgentResponse {
   evals: any[];
+  instructions: string;
+  name: string;
+  id: string;
 }
 
 export interface GetToolResponse {
@@ -64,14 +95,70 @@ export interface GetToolResponse {
   outputSchema: string;
 }
 
-export interface GetWorkflowResponse {
+export interface GetLegacyWorkflowResponse {
   name: string;
   triggerSchema: string;
   steps: Record<string, StepAction<any, any, any, any>>;
   stepGraph: StepGraph;
   stepSubscriberGraph: Record<string, StepGraph>;
+  workflowId?: string;
+}
+
+export interface GetWorkflowRunsParams {
+  fromDate?: Date;
+  toDate?: Date;
+  limit?: number;
+  offset?: number;
+  resourceId?: string;
+}
+
+export type GetLegacyWorkflowRunsResponse = LegacyWorkflowRuns;
+
+export type GetWorkflowRunsResponse = WorkflowRuns;
+
+export type GetWorkflowRunByIdResponse = WorkflowRun;
+
+export type GetWorkflowRunExecutionResultResponse = WatchEvent['payload']['workflowState'];
+
+export type LegacyWorkflowRunResult = {
+  activePaths: Record<string, { status: string; suspendPayload?: any; stepPath: string[] }>;
+  results: CoreLegacyWorkflowRunResult<any, any, any>['results'];
+  timestamp: number;
+  runId: string;
+};
+
+export interface GetWorkflowResponse {
+  name: string;
+  description?: string;
+  steps: {
+    [key: string]: {
+      id: string;
+      description: string;
+      inputSchema: string;
+      outputSchema: string;
+      resumeSchema: string;
+      suspendSchema: string;
+    };
+  };
+  allSteps: {
+    [key: string]: {
+      id: string;
+      description: string;
+      inputSchema: string;
+      outputSchema: string;
+      resumeSchema: string;
+      suspendSchema: string;
+      isWorkflow: boolean;
+    };
+  };
+  stepGraph: Workflow['serializedStepGraph'];
+  inputSchema: string;
+  outputSchema: string;
 }
 
+export type WorkflowWatchResult = WatchEvent & { runId: string };
+
+export type WorkflowRunResult = WorkflowResult<any, any>;
 export interface UpsertVectorParams {
   indexName: string;
   vectors: number[][];
@@ -103,20 +190,33 @@ export interface GetVectorIndexResponse {
 }
 
 export interface SaveMessageToMemoryParams {
-  messages: MessageType[];
+  messages: MastraMessageV1[];
   agentId: string;
 }
 
-export type SaveMessageToMemoryResponse = MessageType[];
+export interface SaveNetworkMessageToMemoryParams {
+  messages: MastraMessageV1[];
+  networkId: string;
+}
+
+export type SaveMessageToMemoryResponse = MastraMessageV1[];
 
 export interface CreateMemoryThreadParams {
-  title: string;
-  metadata: Record<string, any>;
-  resourceid: string;
-  threadId: string;
+  title?: string;
+  metadata?: Record<string, any>;
+  resourceId: string;
+  threadId?: string;
   agentId: string;
 }
 
+export interface CreateNetworkMemoryThreadParams {
+  title?: string;
+  metadata?: Record<string, any>;
+  resourceId: string;
+  threadId?: string;
+  networkId: string;
+}
+
 export type CreateMemoryThreadResponse = StorageThreadType;
 
 export interface GetMemoryThreadParams {
@@ -124,12 +224,24 @@ export interface GetMemoryThreadParams {
   agentId: string;
 }
 
+export interface GetNetworkMemoryThreadParams {
+  resourceId: string;
+  networkId: string;
+}
+
 export type GetMemoryThreadResponse = StorageThreadType[];
 
 export interface UpdateMemoryThreadParams {
   title: string;
   metadata: Record<string, any>;
-  resourceid: string;
+  resourceId: string;
+}
+
+export interface GetMemoryThreadMessagesParams {
+  /**
+   * Limit the number of messages to retrieve (default: 40)
+   */
+  limit?: number;
 }
 
 export interface GetMemoryThreadMessagesResponse {
@@ -139,19 +251,77 @@ export interface GetMemoryThreadMessagesResponse {
 
 export interface GetLogsParams {
   transportId: string;
+  fromDate?: Date;
+  toDate?: Date;
+  logLevel?: LogLevel;
+  filters?: Record<string, string>;
+  page?: number;
+  perPage?: number;
 }
 
 export interface GetLogParams {
   runId: string;
   transportId: string;
+  fromDate?: Date;
+  toDate?: Date;
+  logLevel?: LogLevel;
+  filters?: Record<string, string>;
+  page?: number;
+  perPage?: number;
 }
 
-export type GetLogsResponse = BaseLogMessage[];
+export type GetLogsResponse = {
+  logs: BaseLogMessage[];
+  total: number;
+  page: number;
+  perPage: number;
+  hasMore: boolean;
+};
 
 export type RequestFunction = (path: string, options?: RequestOptions) => Promise<any>;
 
+type SpanStatus = {
+  code: number;
+};
+
+type SpanOther = {
+  droppedAttributesCount: number;
+  droppedEventsCount: number;
+  droppedLinksCount: number;
+};
+
+type SpanEventAttributes = {
+  key: string;
+  value: { [key: string]: string | number | boolean | null };
+};
+
+type SpanEvent = {
+  attributes: SpanEventAttributes[];
+  name: string;
+  timeUnixNano: string;
+  droppedAttributesCount: number;
+};
+
+type Span = {
+  id: string;
+  parentSpanId: string | null;
+  traceId: string;
+  name: string;
+  scope: string;
+  kind: number;
+  status: SpanStatus;
+  events: SpanEvent[];
+  links: any[];
+  attributes: Record<string, string | number | boolean | null>;
+  startTime: number;
+  endTime: number;
+  duration: number;
+  other: SpanOther;
+  createdAt: string;
+};
+
 export interface GetTelemetryResponse {
-  traces: any[];
+  traces: Span[];
 }
 
 export interface GetTelemetryParams {
@@ -160,4 +330,93 @@ export interface GetTelemetryParams {
   page?: number;
   perPage?: number;
   attribute?: Record<string, string>;
+  fromDate?: Date;
+  toDate?: Date;
+}
+
+export interface GetNetworkResponse {
+  id: string;
+  name: string;
+  instructions: string;
+  agents: Array<{
+    name: string;
+    provider: string;
+    modelId: string;
+  }>;
+  routingModel: {
+    provider: string;
+    modelId: string;
+  };
+  state?: Record<string, any>;
+}
+
+export interface GetVNextNetworkResponse {
+  id: string;
+  name: string;
+  instructions: string;
+  agents: Array<{
+    name: string;
+    provider: string;
+    modelId: string;
+  }>;
+  routingModel: {
+    provider: string;
+    modelId: string;
+  };
+  workflows: Array<{
+    name: string;
+    description: string;
+    inputSchema: string | undefined;
+    outputSchema: string | undefined;
+  }>;
+  tools: Array<{
+    id: string;
+    description: string;
+  }>;
+}
+
+export interface GenerateVNextNetworkResponse {
+  task: string;
+  result: string;
+  resourceId: string;
+  resourceType: 'none' | 'tool' | 'agent' | 'workflow';
+}
+
+export interface GenerateOrStreamVNextNetworkParams {
+  message: string;
+  threadId?: string;
+  resourceId?: string;
+}
+
+export interface LoopStreamVNextNetworkParams {
+  message: string;
+  threadId?: string;
+  resourceId?: string;
+  maxIterations?: number;
+}
+
+export interface LoopVNextNetworkResponse {
+  status: 'success';
+  result: {
+    text: string;
+  };
+  steps: WorkflowResult<any, any>['steps'];
+}
+
+export interface McpServerListResponse {
+  servers: ServerInfo[];
+  next: string | null;
+  total_count: number;
+}
+
+export interface McpToolInfo {
+  id: string;
+  name: string;
+  description?: string;
+  inputSchema: string;
+  toolType?: MCPToolType;
+}
+
+export interface McpServerToolListResponse {
+  tools: McpToolInfo[];
 }

package/src/utils/index.ts

@@ -0,0 +1,11 @@
+import { RuntimeContext } from '@mastra/core/runtime-context';
+
+export function parseClientRuntimeContext(runtimeContext?: RuntimeContext | Record<string, any>) {
+  if (runtimeContext) {
+    if (runtimeContext instanceof RuntimeContext) {
+      return Object.fromEntries(runtimeContext.entries());
+    }
+    return runtimeContext;
+  }
+  return undefined;
+}

package/src/utils/process-client-tools.ts

@@ -0,0 +1,32 @@
+import { isVercelTool } from '@mastra/core/tools';
+import { zodToJsonSchema } from './zod-to-json-schema';
+import type { ToolsInput } from '@mastra/core/agent';
+
+export function processClientTools(clientTools: ToolsInput | undefined): ToolsInput | undefined {
+  if (!clientTools) {
+    return undefined;
+  }
+
+  return Object.fromEntries(
+    Object.entries(clientTools).map(([key, value]) => {
+      if (isVercelTool(value)) {
+        return [
+          key,
+          {
+            ...value,
+            parameters: value.parameters ? zodToJsonSchema(value.parameters) : undefined,
+          },
+        ];
+      } else {
+        return [
+          key,
+          {
+            ...value,
+            inputSchema: value.inputSchema ? zodToJsonSchema(value.inputSchema) : undefined,
+            outputSchema: value.outputSchema ? zodToJsonSchema(value.outputSchema) : undefined,
+          },
+        ];
+      }
+    }),
+  );
+}

package/src/utils/zod-to-json-schema.ts

@@ -0,0 +1,10 @@
+import { ZodSchema } from 'zod';
+import originalZodToJsonSchema from 'zod-to-json-schema';
+
+export function zodToJsonSchema<T extends ZodSchema | any>(zodSchema: T) {
+  if (!(zodSchema instanceof ZodSchema)) {
+    return zodSchema;
+  }
+
+  return originalZodToJsonSchema(zodSchema, { $refStrategy: 'none' });
+}