@agent-os-sdk/client 0.3.0 → 0.3.2

package/src/modules/metrics.ts

@@ -1,20 +1,27 @@
 /**
  * Metrics Module - Fully Typed
+ * 
+ * ALL HTTP goes through rawClient - no direct fetch calls.
  */
 
+import type { RawClient } from "../client/raw.js";
+
 export interface MetricsResponse {
     raw: string;
 }
 
 export class MetricsModule {
-    constructor(private baseUrl: string, private headers: () => Record<string, string>) { }
+    constructor(private client: RawClient) { }
 
     /**
      * Get Prometheus metrics.
+     * 
+     * Uses rawClient - headers resolved asynchronously.
      */
     async get(): Promise<MetricsResponse> {
-        const response = await fetch(`${this.baseUrl}/metrics`, {
-            headers: this.headers(),
+        // Use streamGet for raw text response (metrics endpoint returns text/plain)
+        const response = await this.client.streamGet("/metrics", {
+            headers: { Accept: "text/plain" }
         });
 
         if (!response.ok) {

package/src/modules/runs.ts

@@ -9,7 +9,7 @@
 
 import type { RawClient, APIResponse, components } from "../client/raw.js";
 import type { PaginationParams, PaginatedResponse } from "../client/helpers.js";
-import { streamSSE, type SSEEvent, type RunStreamEvent, type SSEOptions } from "../sse/client.js";
+import { parseSSE, type SSEEvent, type RunStreamEvent, type SSEOptions } from "../sse/client.js";
 
 // Type aliases from OpenAPI
 type WaitRunResponse = components["schemas"]["WaitRunResponse"];
@@ -91,11 +91,7 @@ export interface RunEventDto {
 }
 
 export class RunsModule {
-    constructor(
-        private client: RawClient,
-        private baseUrl: string,
-        private headers: () => Record<string, string>
-    ) { }
+    constructor(private client: RawClient) { }
 
     // ======================== CRUD ========================
 
@@ -117,7 +113,6 @@ export class RunsModule {
     }): Promise<APIResponse<CreateRunResponse>> {
         return this.client.POST<CreateRunResponse>("/v1/api/runs", {
             body,
-            headers: this.headers(),
         });
     }
 
@@ -127,7 +122,6 @@ export class RunsModule {
     async get(runId: string): Promise<APIResponse<Run>> {
         return this.client.GET<Run>("/v1/api/runs/{runId}", {
             params: { path: { runId } },
-            headers: this.headers(),
         });
     }
 
@@ -141,7 +135,6 @@ export class RunsModule {
     }): Promise<APIResponse<RunListResponse>> {
         return this.client.GET<RunListResponse>("/v1/api/runs", {
             params: { query: params },
-            headers: this.headers(),
         });
     }
 
@@ -158,7 +151,6 @@ export class RunsModule {
     }): Promise<APIResponse<WaitRunResponse>> {
         return this.client.POST<WaitRunResponse>("/v1/api/runs/wait", {
             body,
-            headers: this.headers(),
         });
     }
 
@@ -171,7 +163,6 @@ export class RunsModule {
     }): Promise<APIResponse<BatchRunResponse>> {
         return this.client.POST<BatchRunResponse>("/v1/api/runs/batch", {
             body,
-            headers: this.headers(),
         });
     }
 
@@ -182,7 +173,6 @@ export class RunsModule {
         return this.client.POST<CancelRunResponse>("/v1/api/runs/{runId}/cancel", {
             params: { path: { runId } },
             body: { reason },
-            headers: this.headers(),
         });
     }
 
@@ -212,7 +202,6 @@ export class RunsModule {
         return this.client.POST<Run>("/v1/api/runs/{runId}/resume", {
             params: { path: { runId } },
             body,
-            headers: this.headers(),
         });
     }
 
@@ -222,7 +211,6 @@ export class RunsModule {
     async rerun(runId: string): Promise<APIResponse<CreateRunResponse>> {
         return this.client.POST<CreateRunResponse>("/v1/api/runs/{runId}/rerun", {
             params: { path: { runId } },
-            headers: this.headers(),
         });
     }
 
@@ -259,7 +247,6 @@ export class RunsModule {
                 mode: options?.mode,
                 reason: options?.reason
             },
-            headers: this.headers(),
         });
     }
 
@@ -275,7 +262,6 @@ export class RunsModule {
     async getEvents(runId: string, params?: PaginationParams): Promise<APIResponse<RunEventsResponse>> {
         return this.client.GET<RunEventsResponse>("/v1/api/runs/{runId}/events", {
             params: { path: { runId }, query: params },
-            headers: this.headers(),
         });
     }
 
@@ -315,7 +301,6 @@ export class RunsModule {
                     limit: params?.limit ?? 100
                 }
             },
-            headers: this.headers(),
         });
     }
 
@@ -327,7 +312,6 @@ export class RunsModule {
     async getCheckpoints(runId: string): Promise<APIResponse<CheckpointListResponse>> {
         return this.client.GET<CheckpointListResponse>("/v1/api/runs/{runId}/checkpoints", {
             params: { path: { runId } },
-            headers: this.headers(),
         });
     }
 
@@ -345,12 +329,12 @@ export class RunsModule {
      * }
      * ```
      */
-    stream(runId: string, options?: SSEOptions): AsyncGenerator<SSEEvent<RunStreamEvent>> {
-        const url = `${this.baseUrl}/v1/api/runs/${runId}/stream`;
-        return streamSSE<RunStreamEvent>(url, {
-            ...options,
-            headers: { ...this.headers(), ...options?.headers },
+    async *stream(runId: string, options?: SSEOptions): AsyncGenerator<SSEEvent<RunStreamEvent>> {
+        const response = await this.client.streamGet("/v1/api/runs/{runId}/stream", {
+            params: { path: { runId } },
+            headers: options?.headers,
         });
+        yield* parseSSE<RunStreamEvent>(response, { onOpen: options?.onOpen });
     }
 
     /**
@@ -385,11 +369,11 @@ export class RunsModule {
     /**
      * Join an existing run's stream (resume watching).
      */
-    join(runId: string, options?: SSEOptions): AsyncGenerator<SSEEvent<RunStreamEvent>> {
-        const url = `${this.baseUrl}/v1/api/runs/${runId}/join`;
-        return streamSSE<RunStreamEvent>(url, {
-            ...options,
-            headers: { ...this.headers(), ...options?.headers },
+    async *join(runId: string, options?: SSEOptions): AsyncGenerator<SSEEvent<RunStreamEvent>> {
+        const response = await this.client.streamGet("/v1/api/runs/{runId}/join", {
+            params: { path: { runId } },
+            headers: options?.headers,
         });
+        yield* parseSSE<RunStreamEvent>(response, { onOpen: options?.onOpen });
     }
 }

package/src/sse/client.ts

@@ -2,6 +2,9 @@
  * Agent OS SDK - SSE Client
  * 
  * Typed Server-Sent Events client for streaming endpoints.
+ * 
+ * This module provides utilities for parsing SSE responses.
+ * The actual HTTP request should be made via rawClient.streamGet/streamPost.
  */
 
 export type SSEEvent<T = unknown> = {
@@ -19,21 +22,23 @@ export type SSEOptions = {
 };
 
 /**
- * Creates a typed SSE stream from a URL.
+ * Parse SSE events from a Response object.
+ * Use this with rawClient.streamGet() or rawClient.streamPost().
+ * 
+ * @example
+ * ```ts
+ * const response = await client.streamGet("/v1/api/runs/{runId}/stream", {
+ *   params: { path: { runId } }
+ * });
+ * for await (const event of parseSSE<RunStreamEvent>(response)) {
+ *   console.log(event);
+ * }
+ * ```
  */
-export async function* streamSSE<T>(
-    url: string,
-    options: SSEOptions = {}
+export async function* parseSSE<T>(
+    response: Response,
+    options?: { onOpen?: () => void }
 ): AsyncGenerator<SSEEvent<T>> {
-    const response = await fetch(url, {
-        method: "GET",
-        headers: {
-            Accept: "text/event-stream",
-            ...options.headers,
-        },
-        signal: options.signal,
-    });
-
     if (!response.ok) {
         throw new Error(`SSE connection failed: ${response.status}`);
     }
@@ -42,7 +47,7 @@ export async function* streamSSE<T>(
         throw new Error("No response body");
     }
 
-    options.onOpen?.();
+    options?.onOpen?.();
 
     const reader = response.body.getReader();
     const decoder = new TextDecoder();
@@ -84,6 +89,30 @@ export async function* streamSSE<T>(
     }
 }
 
+/**
+ * Legacy streamSSE function - DEPRECATED.
+ * Use rawClient.streamGet() + parseSSE() instead.
+ * 
+ * Kept for backward compatibility during migration.
+ * 
+ * @deprecated Use rawClient.streamGet() + parseSSE() instead
+ */
+export async function* streamSSE<T>(
+    url: string,
+    options: SSEOptions = {}
+): AsyncGenerator<SSEEvent<T>> {
+    const response = await fetch(url, {
+        method: "GET",
+        headers: {
+            Accept: "text/event-stream",
+            ...options.headers,
+        },
+        signal: options.signal,
+    });
+
+    yield* parseSSE<T>(response, { onOpen: options.onOpen });
+}
+
 /**
  * SSE Event types for Run streaming
  */