@ai-sdk/harness-codex 1.0.126 → 1.0.128

package/src/bridge/tool-relay-auth.ts

@@ -1,156 +0,0 @@
-export type ToolRelayCall = {
-  toolName: string;
-  input: unknown;
-};
-
-export type ToolRelayResult = {
-  output: unknown;
-  isError?: boolean;
-};
-
-export class ToolRelayAuthorizer {
-  private readonly ttlMs: number;
-  private readonly now: () => number;
-  private readonly authorizations: Array<{ key: string; expiresAt: number }> =
-    [];
-  private readonly pendingRequests: Array<{
-    key: string;
-    expiresAt: number;
-    timeout: ReturnType<typeof setTimeout>;
-    resolve: (authorized: boolean) => void;
-  }> = [];
-
-  constructor({
-    ttlMs = 10_000,
-    now = Date.now,
-  }: {
-    ttlMs?: number;
-    now?: () => number;
-  } = {}) {
-    this.ttlMs = ttlMs;
-    this.now = now;
-  }
-
-  authorizeToolCall(call: ToolRelayCall): void {
-    this.pruneExpired();
-    const key = toolRelayCallKey(call);
-    const pendingRequestIndex = this.pendingRequests.findIndex(
-      request => request.key === key,
-    );
-    if (pendingRequestIndex !== -1) {
-      const [pendingRequest] = this.pendingRequests.splice(
-        pendingRequestIndex,
-        1,
-      );
-      clearTimeout(pendingRequest.timeout);
-      pendingRequest.resolve(true);
-      return;
-    }
-    this.authorizations.push({
-      key,
-      expiresAt: this.now() + this.ttlMs,
-    });
-  }
-
-  waitForToolCallAuthorization(call: ToolRelayCall): Promise<boolean> {
-    this.pruneExpired();
-    const key = toolRelayCallKey(call);
-    const authorizationIndex = this.authorizations.findIndex(
-      authorization => authorization.key === key,
-    );
-    if (authorizationIndex !== -1) {
-      this.authorizations.splice(authorizationIndex, 1);
-      return Promise.resolve(true);
-    }
-
-    const expiresAt = this.now() + this.ttlMs;
-    return new Promise(resolve => {
-      const pendingRequest = {
-        key,
-        expiresAt,
-        timeout: setTimeout(() => {
-          const index = this.pendingRequests.indexOf(pendingRequest);
-          if (index !== -1) this.pendingRequests.splice(index, 1);
-          resolve(false);
-        }, this.ttlMs),
-        resolve,
-      };
-      this.pendingRequests.push(pendingRequest);
-    });
-  }
-
-  close(): void {
-    this.authorizations.length = 0;
-    for (const pendingRequest of this.pendingRequests.splice(0)) {
-      clearTimeout(pendingRequest.timeout);
-      pendingRequest.resolve(false);
-    }
-  }
-
-  private pruneExpired(): void {
-    const now = this.now();
-    for (let i = this.authorizations.length - 1; i >= 0; i--) {
-      if (this.authorizations[i].expiresAt <= now) {
-        this.authorizations.splice(i, 1);
-      }
-    }
-    for (let i = this.pendingRequests.length - 1; i >= 0; i--) {
-      const pendingRequest = this.pendingRequests[i];
-      if (pendingRequest.expiresAt <= now) {
-        this.pendingRequests.splice(i, 1);
-        clearTimeout(pendingRequest.timeout);
-        pendingRequest.resolve(false);
-      }
-    }
-  }
-}
-
-export class ToolRelayPendingCalls {
-  private readonly calls = new Map<string, Promise<ToolRelayResult>>();
-
-  begin({
-    call,
-    run,
-  }: {
-    call: ToolRelayCall;
-    run: () => Promise<ToolRelayResult>;
-  }): { result: Promise<ToolRelayResult>; isNew: boolean } {
-    const key = toolRelayCallKey(call);
-    const existing = this.calls.get(key);
-    if (existing) return { result: existing, isNew: false };
-
-    const result = run();
-    this.calls.set(key, result);
-    void result
-      .finally(() => {
-        if (this.calls.get(key) === result) {
-          this.calls.delete(key);
-        }
-      })
-      .catch(() => {});
-    return { result, isNew: true };
-  }
-}
-
-function toolRelayCallKey({ toolName, input }: ToolRelayCall): string {
-  return `${toolName}\0${canonicalJson(input ?? {})}`;
-}
-
-function canonicalJson(value: unknown): string {
-  return JSON.stringify(normalizeJsonValue(value));
-}
-
-function normalizeJsonValue(value: unknown): unknown {
-  if (Array.isArray(value)) {
-    return value.map(normalizeJsonValue);
-  }
-  if (value && typeof value === 'object') {
-    return Object.fromEntries(
-      Object.entries(value as Record<string, unknown>)
-        .filter(([, entryValue]) => entryValue !== undefined)
-        .sort(([left], [right]) => left.localeCompare(right))
-        .map(([key, entryValue]) => [key, normalizeJsonValue(entryValue)]),
-    );
-  }
-  return value;
-}

package/src/bridge/tool-relay.ts

@@ -1,119 +0,0 @@
-import { createServer, type Server } from 'node:http';
-import {
-  ToolRelayAuthorizer,
-  ToolRelayPendingCalls,
-  type ToolRelayCall,
-} from './tool-relay-auth';
-
-export type ToolRelay = {
-  port: number;
-  close(): void;
-  authorizeToolCall(call: ToolRelayCall): void;
-};
-
-export async function startAuthorizedToolRelay({
-  tools,
-  emit,
-  requestToolResult,
-  authorizer = new ToolRelayAuthorizer(),
-}: {
-  tools: ReadonlyArray<{ name: string }>;
-  emit: (message: Record<string, unknown>) => void;
-  requestToolResult: (
-    toolCallId: string,
-  ) => Promise<{ output: unknown; isError?: boolean }>;
-  authorizer?: ToolRelayAuthorizer;
-}): Promise<ToolRelay> {
-  const toolNames = new Set(tools.map(tool => tool.name));
-  const pendingCalls = new ToolRelayPendingCalls();
-
-  const server = createServer(async (req, res) => {
-    try {
-      if (req.method !== 'POST' || req.url !== '/') {
-        res.writeHead(401, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'unauthorized tool relay request' }));
-        return;
-      }
-      const chunks: Buffer[] = [];
-      for await (const chunk of req) {
-        chunks.push(chunk as Buffer);
-      }
-      const body = Buffer.concat(chunks).toString('utf8');
-      const { requestId, toolName, input } = JSON.parse(body) as {
-        requestId: string;
-        toolName: string;
-        input: unknown;
-      };
-
-      if (!toolNames.has(toolName)) {
-        res.writeHead(403, { 'Content-Type': 'application/json' });
-        res.end(
-          JSON.stringify({ error: `Tool "${toolName}" is not available` }),
-        );
-        return;
-      }
-      const relayCall = { toolName, input };
-      if (!(await authorizer.waitForToolCallAuthorization(relayCall))) {
-        res.writeHead(401, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'unauthorized tool relay request' }));
-        return;
-      }
-
-      const { result } = pendingCalls.begin({
-        call: relayCall,
-        run: async () => {
-          emit({
-            type: 'tool-call',
-            toolCallId: requestId,
-            toolName,
-            input: JSON.stringify(input ?? {}),
-            providerExecuted: false,
-          });
-
-          const toolResult = await requestToolResult(requestId);
-          emit({
-            type: 'tool-result',
-            toolCallId: requestId,
-            toolName,
-            result: toolResult.output ?? null,
-            isError: !!toolResult.isError,
-          });
-          return toolResult;
-        },
-      });
-      const { output } = await result;
-
-      res.writeHead(200, { 'Content-Type': 'application/json' });
-      res.end(JSON.stringify({ result: output }));
-    } catch (error) {
-      res.writeHead(500, { 'Content-Type': 'application/json' });
-      res.end(
-        JSON.stringify({
-          error: error instanceof Error ? error.message : String(error),
-        }),
-      );
-    }
-  });
-
-  await new Promise<void>(resolve =>
-    server.listen(0, '127.0.0.1', () => resolve()),
-  );
-  const address = server.address();
-  if (!address || typeof address === 'string') {
-    throw new Error('tool relay did not expose a numeric port');
-  }
-  return {
-    port: address.port,
-    close: () => {
-      authorizer.close();
-      closeServer(server);
-    },
-    authorizeToolCall: call => authorizer.authorizeToolCall(call),
-  };
-}
-
-function closeServer(server: Server): void {
-  try {
-    server.close();
-  } catch {}
-}