@meistrari/agent-sdk 0.1.3 → 0.3.0

package/README.md

@@ -93,6 +93,33 @@ Multi-turn lifecycle rules:
 - Treat `completed`, `failed`, and `cancelled` as non-normal follow-up states in SDK consumers.
 - The SDK v4 path does not use the legacy `/v3/sessions/{sessionId}/continue` endpoint.
 
+### Update an agent model
+
+```ts
+const update = await client.updateAgentModel({
+    repository: 'support-bot',
+    model: 'claude-sonnet-4-5',
+    commitMessage: 'Switch support bot model',
+})
+
+console.log(update.commitHash)
+```
+
+`updateAgentModel` writes `agent.config.json` on the main branch and lets agent-api
+synchronize provider-specific template files when the model provider changes.
+
+### Fetch a timeline summary
+
+```ts
+const timeline = await client.fetchTimeline(sessionId, { signal })
+
+console.log(timeline.status, timeline.metrics, timeline.spans)
+```
+
+`fetchTimeline` returns the persisted v4 timeline summary only: `status`, `metrics`,
+`prompt`, and `spans`. It does not return per-event detail. Consumers that need timeline
+events should consume `streamSession` and merge stream-derived timeline events locally.
+
 ### Resolve Vault references
 
 ```ts
@@ -115,5 +142,7 @@ This package mirrors `@meistrari/vault-sdk` and is published as `UNLICENSED`.
 
 ## Scope
 
-Focused on sandbox execution: `executeAgent`, `streamSession`, and `resolveReference`.
-Agent CRUD, legacy polling, and timelines are intentionally out of scope.
+Focused on sandbox execution and the public v4 consumer paths: `executeAgent`,
+`streamSession`, `updateAgentModel`, `fetchTimeline`, and `resolveReference`. Agent CRUD,
+legacy polling, and the internal sandbox timeline callback are intentionally out of
+scope.

package/dist/index.cjs

@@ -1,17 +1,18 @@
 'use strict';
 
 const vaultSdk = require('@meistrari/vault-sdk');
-const zod = require('zod');
+const schemas = require('./schemas.cjs');
+require('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() {
@@ -22,7 +23,7 @@ class DataTokenAuthStrategy {
 }
 class APIKeyAuthStrategy {
   constructor(apiKey) {
-    __publicField(this, "apiKey");
+    __publicField$1(this, "apiKey");
     this.apiKey = apiKey;
   }
   getHeaders() {
@@ -32,6 +33,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);
@@ -39,6 +46,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) {
@@ -54,104 +62,22 @@ ${text}`,
     );
   }
 }
-
-const sessionStatusSchema = zod.z.enum([
-  "pending",
-  "running",
-  "completed",
-  "failed",
-  "waiting_messages",
-  "cancelled"
-]);
-const vaultReferenceSchema = zod.z.string().regex(/^vault:\/\/\S+$/, "vaultRef must start with vault:// and cannot contain whitespace");
-const agentInputSchema = zod.z.object({
-  vaultRef: vaultReferenceSchema,
-  filename: zod.z.string().min(1, "Filename is required").max(255, "Filename must be 255 characters or less"),
-  metadata: zod.z.string().max(16384, "Metadata must be 16,384 characters or less").optional()
-}).strict();
-const executeAgentRequestSchema = zod.z.object({
-  sessionId: zod.z.string().uuid().optional(),
-  organizationName: zod.z.string().min(1).max(200).optional(),
-  repository: zod.z.string().min(1).max(200).optional(),
-  ref: zod.z.string().max(200).optional(),
-  message: zod.z.string().min(1).max(8e5).optional(),
-  inputs: zod.z.array(agentInputSchema).optional(),
-  environmentVariables: zod.z.record(zod.z.string(), zod.z.string()).optional(),
-  recover: zod.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 = zod.z.object({
-  success: zod.z.boolean(),
-  sessionId: zod.z.string().optional(),
-  error: zod.z.string().optional()
-});
-const sessionStatusEventSchema = zod.z.object({
-  kind: zod.z.literal("status"),
-  sessionId: zod.z.string(),
-  status: sessionStatusSchema,
-  error: zod.z.string().optional(),
-  createdAt: zod.z.number(),
-  updatedAt: zod.z.number()
-});
-const sessionStepsEventSchema = zod.z.object({
-  kind: zod.z.literal("steps"),
-  sessionId: zod.z.string(),
-  status: sessionStatusSchema,
-  steps: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())),
-  nextCursor: zod.z.number().nullable(),
-  createdAt: zod.z.number(),
-  updatedAt: zod.z.number()
-});
-const sessionResultEventSchema = zod.z.object({
-  kind: zod.z.literal("result"),
-  sessionId: zod.z.string(),
-  status: zod.z.enum(["completed", "waiting_messages"]),
-  result: zod.z.record(zod.z.string(), zod.z.unknown()),
-  nextCursor: zod.z.number().nullable(),
-  createdAt: zod.z.number(),
-  updatedAt: zod.z.number()
-});
-const sessionErrorEventSchema = zod.z.object({
-  kind: zod.z.literal("error"),
-  sessionId: zod.z.string(),
-  error: zod.z.string()
-});
-const sessionTimelineFinalizeEventSchema = zod.z.object({
-  kind: zod.z.literal("timeline-finalize"),
-  sessionId: zod.z.string(),
-  status: sessionStatusSchema,
-  metrics: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
-  prompt: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
-  spans: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).nullable().optional(),
-  events: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).nullable().optional(),
-  continuation: zod.z.record(zod.z.string(), zod.z.unknown()).nullable().optional(),
-  createdAt: zod.z.number(),
-  updatedAt: zod.z.number()
-});
-const sessionStreamEventSchema = zod.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");
@@ -198,9 +124,9 @@ function getEventKind(event) {
 }
 function parseKnownEvent(event) {
   const eventKind = getEventKind(event);
-  if (!eventKind || !SESSION_STREAM_EVENT_KINDS.has(eventKind))
+  if (!eventKind || !schemas.SESSION_STREAM_EVENT_KINDS.has(eventKind))
     return void 0;
-  const parsed = sessionStreamEventSchema.safeParse(event);
+  const parsed = schemas.sessionStreamEventSchema.safeParse(event);
   if (!parsed.success)
     throw new Error(parsed.error.message);
   return parsed.data;
@@ -261,24 +187,49 @@ 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;
   }
   async function executeAgent(input) {
-    const body = executeAgentRequestSchema.parse(input);
+    const body = schemas.executeAgentRequestSchema.parse(input);
     const response = await request({
       method: "POST",
       path: "/v4/agents/execute",
       body
     });
-    return executeAgentResponseSchema.parse(await response.json());
+    return schemas.executeAgentResponseSchema.parse(await response.json());
+  }
+  async function updateAgentModel(input) {
+    const { repository, ...body } = schemas.updateAgentModelRequestSchema.parse(input);
+    const response = await request({
+      method: "PUT",
+      path: `/v4/agents/${encodeURIComponent(repository)}/model`,
+      body
+    });
+    return schemas.updateAgentModelResponseSchema.parse(await response.json());
+  }
+  async function fetchTimeline(sessionId, options) {
+    const parsedSessionId = schemas.sessionTimelineIdSchema.parse(sessionId);
+    const response = await request({
+      method: "GET",
+      path: `/v4/sessions/${encodeURIComponent(parsedSessionId)}/timeline`,
+      signal: options?.signal
+    });
+    return schemas.sessionTimelineResponseSchema.parse(await response.json());
   }
   async function streamSession(sessionId, options) {
     const response = await request({
@@ -316,16 +267,14 @@ function agentClient(config) {
       return JSON.parse(await vaultFile.content.text());
     return vaultFile.content.arrayBuffer();
   }
-  return { executeAgent, streamSession, resolveReference };
+  return { executeAgent, updateAgentModel, fetchTimeline, streamSession, resolveReference };
 }
 
 exports.APIKeyAuthStrategy = APIKeyAuthStrategy;
 exports.DataTokenAuthStrategy = DataTokenAuthStrategy;
 exports.FetchError = FetchError;
+exports.NetworkError = NetworkError;
 exports.agentClient = agentClient;
-exports.agentInputSchema = agentInputSchema;
-exports.executeAgentRequestSchema = executeAgentRequestSchema;
-exports.executeAgentResponseSchema = executeAgentResponseSchema;
+exports.isFetchError = isFetchError;
+exports.isNetworkError = isNetworkError;
 exports.parseSessionStream = parseSessionStream;
-exports.sessionStatusSchema = sessionStatusSchema;
-exports.sessionStreamEventSchema = sessionStreamEventSchema;

package/dist/index.d.cts

@@ -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.cjs';
+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.cjs';
+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.d.mts

@@ -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.mjs';
+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.mjs';
+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 };