@meistrari/agent-sdk 0.1.3 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import { z } from 'zod';
+import { E as ExecuteAgentRequest, a as ExecuteAgentResponse, U as UpdateAgentModelRequest, b as UpdateAgentModelResponse, S as SessionTimelineResponse, c as SessionStreamEvent } from './shared/agent-sdk.4ad2c746.js';
+export { A as AgentInput, d as SessionStatus, T as TimelineEvent, e as TimelineMetrics, f as TimelinePrompt, g as TimelineRunTurnMetrics, h as TimelineSpan, i as TimelineToolResult } from './shared/agent-sdk.4ad2c746.js';
+import 'zod';
 
 interface AuthStrategy {
     getHeaders: () => Headers;
@@ -14,107 +16,6 @@ declare class APIKeyAuthStrategy implements AuthStrategy {
     getHeaders(): Headers;
 }
 
-declare const sessionStatusSchema: z.ZodEnum<{
-    pending: "pending";
-    running: "running";
-    completed: "completed";
-    failed: "failed";
-    waiting_messages: "waiting_messages";
-    cancelled: "cancelled";
-}>;
-type SessionStatus = z.infer<typeof sessionStatusSchema>;
-declare const agentInputSchema: z.ZodObject<{
-    vaultRef: z.ZodString;
-    filename: z.ZodString;
-    metadata: z.ZodOptional<z.ZodString>;
-}, z.core.$strict>;
-type AgentInput = z.infer<typeof agentInputSchema>;
-declare const executeAgentRequestSchema: z.ZodObject<{
-    sessionId: z.ZodOptional<z.ZodString>;
-    organizationName: z.ZodOptional<z.ZodString>;
-    repository: z.ZodOptional<z.ZodString>;
-    ref: z.ZodOptional<z.ZodString>;
-    message: z.ZodOptional<z.ZodString>;
-    inputs: z.ZodOptional<z.ZodArray<z.ZodObject<{
-        vaultRef: z.ZodString;
-        filename: z.ZodString;
-        metadata: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>>;
-    environmentVariables: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
-    recover: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strict>;
-type ExecuteAgentRequest = z.infer<typeof executeAgentRequestSchema>;
-declare const executeAgentResponseSchema: z.ZodObject<{
-    success: z.ZodBoolean;
-    sessionId: z.ZodOptional<z.ZodString>;
-    error: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-type ExecuteAgentResponse = z.infer<typeof executeAgentResponseSchema>;
-declare const sessionStreamEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
-    kind: z.ZodLiteral<"status">;
-    sessionId: z.ZodString;
-    status: z.ZodEnum<{
-        pending: "pending";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        waiting_messages: "waiting_messages";
-        cancelled: "cancelled";
-    }>;
-    error: z.ZodOptional<z.ZodString>;
-    createdAt: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"steps">;
-    sessionId: z.ZodString;
-    status: z.ZodEnum<{
-        pending: "pending";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        waiting_messages: "waiting_messages";
-        cancelled: "cancelled";
-    }>;
-    steps: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
-    nextCursor: z.ZodNullable<z.ZodNumber>;
-    createdAt: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"result">;
-    sessionId: z.ZodString;
-    status: z.ZodEnum<{
-        completed: "completed";
-        waiting_messages: "waiting_messages";
-    }>;
-    result: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-    nextCursor: z.ZodNullable<z.ZodNumber>;
-    createdAt: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"timeline-finalize">;
-    sessionId: z.ZodString;
-    status: z.ZodEnum<{
-        pending: "pending";
-        running: "running";
-        completed: "completed";
-        failed: "failed";
-        waiting_messages: "waiting_messages";
-        cancelled: "cancelled";
-    }>;
-    metrics: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    prompt: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    spans: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
-    events: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>>>;
-    continuation: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
-    createdAt: z.ZodNumber;
-    updatedAt: z.ZodNumber;
-}, z.core.$strip>, z.ZodObject<{
-    kind: z.ZodLiteral<"error">;
-    sessionId: z.ZodString;
-    error: z.ZodString;
-}, z.core.$strip>], "kind">;
-type SessionStreamEvent = z.infer<typeof sessionStreamEventSchema>;
-
 interface AgentClientConfig {
     baseUrl: string;
     authStrategy: AuthStrategy;
@@ -124,6 +25,9 @@ interface StreamSessionOptions {
     cursor?: number;
     signal?: AbortSignal;
 }
+interface FetchTimelineOptions {
+    signal?: AbortSignal;
+}
 type ResolveReferenceAs = 'bytes' | 'stream' | 'json';
 interface ResolveReferenceOptions {
     as?: ResolveReferenceAs;
@@ -132,6 +36,8 @@ interface ResolveReferenceOptions {
 
 declare function agentClient(config: AgentClientConfig): {
     executeAgent: (input: ExecuteAgentRequest) => Promise<ExecuteAgentResponse>;
+    updateAgentModel: (input: UpdateAgentModelRequest) => Promise<UpdateAgentModelResponse>;
+    fetchTimeline: (sessionId: string, options?: FetchTimelineOptions) => Promise<SessionTimelineResponse>;
     streamSession: (sessionId: string, options?: StreamSessionOptions) => Promise<AsyncIterable<SessionStreamEvent>>;
     resolveReference: {
         (reference: string, options?: {
@@ -155,11 +61,22 @@ declare class FetchError extends Error {
     readonly url: string;
     readonly method: string;
     readonly response: Response;
+    readonly kind: "http";
     constructor(message: string, url: string, method: string, response: Response);
     static from(url: string, method: string, response: Response): Promise<FetchError>;
 }
+declare class NetworkError extends Error {
+    readonly url: string;
+    readonly method: string;
+    readonly cause: unknown;
+    readonly kind: "network";
+    constructor(url: string, method: string, cause: unknown);
+}
+type AgentRequestError = FetchError | NetworkError;
+declare function isFetchError(error: unknown): error is FetchError;
+declare function isNetworkError(error: unknown): error is NetworkError;
 
 declare function parseSessionStream(stream: ReadableStream<Uint8Array>): AsyncIterable<SessionStreamEvent>;
 
-export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, agentClient, agentInputSchema, executeAgentRequestSchema, executeAgentResponseSchema, parseSessionStream, sessionStatusSchema, sessionStreamEventSchema };
-export type { AgentClient, AgentClientConfig, AgentInput, AuthStrategy, ExecuteAgentRequest, ExecuteAgentResponse, ResolveReferenceAs, ResolveReferenceOptions, SessionStatus, SessionStreamEvent, StreamSessionOptions };
+export { APIKeyAuthStrategy, DataTokenAuthStrategy, ExecuteAgentRequest, ExecuteAgentResponse, FetchError, NetworkError, SessionStreamEvent, SessionTimelineResponse, UpdateAgentModelRequest, UpdateAgentModelResponse, agentClient, isFetchError, isNetworkError, parseSessionStream };
+export type { AgentClient, AgentClientConfig, AgentRequestError, AuthStrategy, FetchTimelineOptions, ResolveReferenceAs, ResolveReferenceOptions, StreamSessionOptions };

package/dist/index.mjs

@@ -1,15 +1,16 @@
 import { VaultFile } from '@meistrari/vault-sdk';
-import { z } from 'zod';
+import { SESSION_STREAM_EVENT_KINDS, sessionStreamEventSchema, executeAgentRequestSchema, executeAgentResponseSchema, updateAgentModelRequestSchema, updateAgentModelResponseSchema, sessionTimelineIdSchema, sessionTimelineResponseSchema } from './schemas.mjs';
+import 'zod';
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => {
-  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => {
+  __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
   return value;
 };
 class DataTokenAuthStrategy {
   constructor(dataToken) {
-    __publicField(this, "dataToken");
+    __publicField$1(this, "dataToken");
     this.dataToken = dataToken;
   }
   getHeaders() {
@@ -20,7 +21,7 @@ class DataTokenAuthStrategy {
 }
 class APIKeyAuthStrategy {
   constructor(apiKey) {
-    __publicField(this, "apiKey");
+    __publicField$1(this, "apiKey");
     this.apiKey = apiKey;
   }
   getHeaders() {
@@ -30,6 +31,12 @@ class APIKeyAuthStrategy {
   }
 }
 
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
 class FetchError extends Error {
   constructor(message, url, method, response) {
     super(message);
@@ -37,6 +44,7 @@ class FetchError extends Error {
     this.url = url;
     this.method = method;
     this.response = response;
+    __publicField(this, "kind", "http");
     this.name = "FetchError";
   }
   static async from(url, method, response) {
@@ -52,104 +60,22 @@ ${text}`,
     );
   }
 }
-
-const sessionStatusSchema = z.enum([
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "waiting_messages",
-  "cancelled"
-]);
-const vaultReferenceSchema = z.string().regex(/^vault:\/\/\S+$/, "vaultRef must start with vault:// and cannot contain whitespace");
-const agentInputSchema = z.object({
-  vaultRef: vaultReferenceSchema,
-  filename: z.string().min(1, "Filename is required").max(255, "Filename must be 255 characters or less"),
-  metadata: z.string().max(16384, "Metadata must be 16,384 characters or less").optional()
-}).strict();
-const executeAgentRequestSchema = z.object({
-  sessionId: z.string().uuid().optional(),
-  organizationName: z.string().min(1).max(200).optional(),
-  repository: z.string().min(1).max(200).optional(),
-  ref: z.string().max(200).optional(),
-  message: z.string().min(1).max(8e5).optional(),
-  inputs: z.array(agentInputSchema).optional(),
-  environmentVariables: z.record(z.string(), z.string()).optional(),
-  recover: z.boolean().optional()
-}).strict().superRefine((data, ctx) => {
-  if (!data.sessionId) {
-    if (!data.organizationName) {
-      ctx.addIssue({ code: "custom", message: "organizationName is required for new sessions", path: ["organizationName"] });
-    }
-    if (!data.repository) {
-      ctx.addIssue({ code: "custom", message: "repository is required for new sessions", path: ["repository"] });
-    }
-    if (!data.message) {
-      ctx.addIssue({ code: "custom", message: "message is required for new sessions", path: ["message"] });
-    }
-  } else if (!data.recover && !data.message) {
-    ctx.addIssue({ code: "custom", message: "message is required for session continuations", path: ["message"] });
-  }
-  if (data.recover && !data.sessionId) {
-    ctx.addIssue({ code: "custom", message: "sessionId is required when recover is true", path: ["sessionId"] });
+class NetworkError extends Error {
+  constructor(url, method, cause) {
+    super(`Failed to ${method} ${url}: ${cause instanceof Error ? cause.message : String(cause)}`, { cause });
+    this.url = url;
+    this.method = method;
+    this.cause = cause;
+    __publicField(this, "kind", "network");
+    this.name = "NetworkError";
   }
-});
-const executeAgentResponseSchema = z.object({
-  success: z.boolean(),
-  sessionId: z.string().optional(),
-  error: z.string().optional()
-});
-const sessionStatusEventSchema = z.object({
-  kind: z.literal("status"),
-  sessionId: z.string(),
-  status: sessionStatusSchema,
-  error: z.string().optional(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionStepsEventSchema = z.object({
-  kind: z.literal("steps"),
-  sessionId: z.string(),
-  status: sessionStatusSchema,
-  steps: z.array(z.record(z.string(), z.unknown())),
-  nextCursor: z.number().nullable(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionResultEventSchema = z.object({
-  kind: z.literal("result"),
-  sessionId: z.string(),
-  status: z.enum(["completed", "waiting_messages"]),
-  result: z.record(z.string(), z.unknown()),
-  nextCursor: z.number().nullable(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionErrorEventSchema = z.object({
-  kind: z.literal("error"),
-  sessionId: z.string(),
-  error: z.string()
-});
-const sessionTimelineFinalizeEventSchema = z.object({
-  kind: z.literal("timeline-finalize"),
-  sessionId: z.string(),
-  status: sessionStatusSchema,
-  metrics: z.record(z.string(), z.unknown()).nullable().optional(),
-  prompt: z.record(z.string(), z.unknown()).nullable().optional(),
-  spans: z.array(z.record(z.string(), z.unknown())).nullable().optional(),
-  events: z.array(z.record(z.string(), z.unknown())).nullable().optional(),
-  continuation: z.record(z.string(), z.unknown()).nullable().optional(),
-  createdAt: z.number(),
-  updatedAt: z.number()
-});
-const sessionStreamEventSchema = z.discriminatedUnion("kind", [
-  sessionStatusEventSchema,
-  sessionStepsEventSchema,
-  sessionResultEventSchema,
-  sessionTimelineFinalizeEventSchema,
-  sessionErrorEventSchema
-]);
-const SESSION_STREAM_EVENT_KINDS = /* @__PURE__ */ new Set(["status", "steps", "result", "timeline-finalize", "error"]);
+}
+function isFetchError(error) {
+  return error instanceof FetchError;
+}
+function isNetworkError(error) {
+  return error instanceof NetworkError;
+}
 
 function normalizeStreamBuffer(buffer) {
   return buffer.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
@@ -259,12 +185,19 @@ function agentClient(config) {
     headers.set("Accept", params.accept ?? "application/json");
     if (params.body !== void 0)
       headers.set("Content-Type", "application/json");
-    const response = await fetch(url, {
-      method: params.method,
-      headers,
-      body: params.body !== void 0 ? JSON.stringify(params.body) : void 0,
-      signal: params.signal
-    });
+    let response;
+    try {
+      response = await fetch(url, {
+        method: params.method,
+        headers,
+        body: params.body !== void 0 ? JSON.stringify(params.body) : void 0,
+        signal: params.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError")
+        throw error;
+      throw new NetworkError(url.toString(), params.method, error);
+    }
     if (!response.ok)
       throw await FetchError.from(url.toString(), params.method, response);
     return response;
@@ -278,6 +211,24 @@ function agentClient(config) {
     });
     return executeAgentResponseSchema.parse(await response.json());
   }
+  async function updateAgentModel(input) {
+    const { repository, ...body } = updateAgentModelRequestSchema.parse(input);
+    const response = await request({
+      method: "PUT",
+      path: `/v4/agents/${encodeURIComponent(repository)}/model`,
+      body
+    });
+    return updateAgentModelResponseSchema.parse(await response.json());
+  }
+  async function fetchTimeline(sessionId, options) {
+    const parsedSessionId = sessionTimelineIdSchema.parse(sessionId);
+    const response = await request({
+      method: "GET",
+      path: `/v4/sessions/${encodeURIComponent(parsedSessionId)}/timeline`,
+      signal: options?.signal
+    });
+    return sessionTimelineResponseSchema.parse(await response.json());
+  }
   async function streamSession(sessionId, options) {
     const response = await request({
       method: "GET",
@@ -314,7 +265,7 @@ function agentClient(config) {
       return JSON.parse(await vaultFile.content.text());
     return vaultFile.content.arrayBuffer();
   }
-  return { executeAgent, streamSession, resolveReference };
+  return { executeAgent, updateAgentModel, fetchTimeline, streamSession, resolveReference };
 }
 
-export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, agentClient, agentInputSchema, executeAgentRequestSchema, executeAgentResponseSchema, parseSessionStream, sessionStatusSchema, sessionStreamEventSchema };
+export { APIKeyAuthStrategy, DataTokenAuthStrategy, FetchError, NetworkError, agentClient, isFetchError, isNetworkError, parseSessionStream };