@superjackfruitlabs/salaam 0.0.1 → 0.0.2

package/src/provider-model.ts

@@ -0,0 +1,86 @@
+import { clampMaxTokensToContext } from '@earendil-works/pi-ai/api/simple-options';
+import type { Api, Model, AuthResult, TranscriptContext } from '@earendil-works/pi-ai';
+import { canonical } from './protocol.js';
+import { getProviderModel, ROUTING_FIELDS, type ProviderRoute } from './provider-config.js';
+export function materialize(model: Model<Api>, auth: AuthResult): Model<Api> {
+  let baseUrl = auth.auth.baseUrl ?? model.baseUrl;
+  for (const [key, value] of Object.entries(auth.env ?? {}))
+    baseUrl = baseUrl.replaceAll('{' + key + '}', value);
+  if (model.provider === 'azure') {
+    const env = auth.env ?? {};
+    baseUrl =
+      env.AZURE_OPENAI_BASE_URL ??
+      (env.AZURE_OPENAI_RESOURCE_NAME
+        ? `https://${env.AZURE_OPENAI_RESOURCE_NAME}.openai.azure.com/openai/v1`
+        : baseUrl);
+  }
+  if (model.provider === 'google-vertex') {
+    const location = auth.env?.GOOGLE_CLOUD_LOCATION ?? 'global';
+    if (!/^[a-z0-9-]+$/.test(location)) throw new Error('Invalid Google Cloud location');
+    baseUrl =
+      location === 'global'
+        ? 'https://aiplatform.googleapis.com'
+        : `https://${location}-aiplatform.googleapis.com`;
+  }
+  if (model.provider === 'amazon-bedrock') {
+    const region =
+      /^arn:aws[^:]*:bedrock:([^:]+):/.exec(model.id)?.[1] ??
+      auth.env?.AWS_REGION ??
+      auth.env?.AWS_DEFAULT_REGION;
+    if (region) {
+      if (!/^[a-z0-9]+(?:-[a-z0-9]+)+$/.test(region)) throw new Error('Invalid AWS region');
+      baseUrl = `https://bedrock-runtime.${region}.amazonaws.com${region.startsWith('cn-') ? '.cn' : ''}`;
+    }
+  }
+  const url = new URL(baseUrl);
+  if (
+    url.protocol !== 'https:' ||
+    url.username ||
+    url.password ||
+    url.hash ||
+    url.search ||
+    /[{}]/.test(baseUrl)
+  )
+    throw new Error('Provider endpoint is not configured');
+  return {
+    ...model,
+    baseUrl: baseUrl.replace(/\/$/, ''),
+    headers: model.headers,
+    compat: {
+      ...model.compat,
+      supportsMidConvoSystemMessages: false,
+      supportsMidConvoToolChanges: false,
+      supportsMidConvoEffort: false,
+      supportsAdditionalTools: false,
+      supportsToolSearch: false,
+      supportsOpenAIGrammarTools: false,
+      allowedFallbackModels: [],
+    },
+  };
+}
+
+/** Non-secret routing configuration becomes part of durable session identity. */
+export function bindProviderConfiguration(route: ProviderRoute, auth: AuthResult): ProviderRoute {
+  const catalog = getProviderModel(route);
+  if (!catalog) throw new Error('Pinned provider model missing');
+  const model = materialize(catalog, auth);
+  const configuration = Object.fromEntries(
+    ROUTING_FIELDS.flatMap((key) => (auth.env?.[key] ? [[key, auth.env[key]!]] : [])),
+  );
+  const changed =
+    route.provider !== 'anthropic' ||
+    model.baseUrl !== catalog.baseUrl ||
+    Object.keys(configuration).length > 0;
+  const binding = changed ? { endpoint: model.baseUrl, configuration } : undefined;
+  if (route.connection && canonical(route.connection) !== canonical(binding))
+    throw new Error(
+      'Provider endpoint or routing configuration changed; use the original configuration or a new session',
+    );
+  return binding ? { ...route, connection: binding } : route;
+}
+
+/** Leave room for the answer instead of emitting Pi's minimum 1,024-token thinking budget under a smaller ceiling. */
+export function generationOptions(model: Model<Api>, context: TranscriptContext, cap: number) {
+  const maxTokens = clampMaxTokensToContext(model, context, cap);
+  return { maxTokens, reasoning: maxTokens >= 2048 ? ('low' as const) : undefined };
+}

package/src/provider-payload.ts

@@ -0,0 +1,263 @@
+import { getCurrentTools, type TranscriptContext } from '@earendil-works/pi-ai';
+import { canonical, object } from './protocol.js';
+import { getProviderModel, validateClaudePayload, type ProviderRoute } from './provider-config.js';
+
+const common = ['model', 'stream', 'tools', 'tool_choice', 'temperature', 'top_p', 'metadata'];
+const allowedFields: Record<string, string[]> = {
+  'anthropic-messages': [
+    ...common,
+    'messages',
+    'system',
+    'max_tokens',
+    'betas',
+    'thinking',
+    'output_config',
+    'top_k',
+    'stop_sequences',
+  ],
+  'openai-completions': [
+    ...common,
+    'messages',
+    'max_tokens',
+    'max_completion_tokens',
+    'store',
+    'stream_options',
+    'reasoning',
+    'reasoning_effort',
+    'thinking',
+    'chat_template_args',
+    'enable_thinking',
+    'tool_stream',
+    'prompt_cache_key',
+    'prompt_cache_retention',
+    'frequency_penalty',
+    'presence_penalty',
+    'repetition_penalty',
+    'min_p',
+    'top_k',
+    'stop',
+  ],
+  'mistral-conversations': [
+    ...common,
+    'messages',
+    'maxTokens',
+    'max_tokens',
+    'toolChoice',
+    'reasoningEffort',
+    'reasoning_effort',
+    'promptMode',
+    'prompt_mode',
+    'promptCacheKey',
+    'prompt_cache_key',
+  ],
+  'openai-responses': [
+    ...common,
+    'input',
+    'store',
+    'max_output_tokens',
+    'include',
+    'reasoning',
+    'prompt_cache_key',
+    'prompt_cache_options',
+    'prompt_cache_retention',
+    'service_tier',
+    'text',
+    'parallel_tool_calls',
+    'instructions',
+  ],
+  'azure-openai-responses': [
+    ...common,
+    'input',
+    'store',
+    'max_output_tokens',
+    'include',
+    'reasoning',
+    'prompt_cache_key',
+    'service_tier',
+    'text',
+    'parallel_tool_calls',
+  ],
+  'openai-codex-responses': [
+    ...common,
+    'input',
+    'store',
+    'include',
+    'reasoning',
+    'prompt_cache_key',
+    'service_tier',
+    'text',
+    'parallel_tool_calls',
+    'instructions',
+  ],
+  'google-generative-ai': ['model', 'contents', 'config'],
+  'google-vertex': ['model', 'contents', 'config'],
+  'bedrock-converse-stream': [
+    'modelId',
+    'messages',
+    'system',
+    'inferenceConfig',
+    'toolConfig',
+    'additionalModelRequestFields',
+    'requestMetadata',
+  ],
+  'pi-messages': ['model', 'context', 'options'],
+};
+function keys(value: Record<string, unknown>, allowed: readonly string[]) {
+  if (Object.keys(value).some((key) => !allowed.includes(key) && value[key] !== undefined))
+    throw new Error('Unsupported provider execution feature');
+}
+function cap(value: unknown, route: ProviderRoute) {
+  if (!Number.isSafeInteger(value) || Number(value) < 1 || Number(value) > route.max_tokens)
+    throw new Error('Unapproved provider output limit');
+}
+function inventory(
+  values: unknown,
+  names: string[],
+  kind: 'function' | 'google' | 'bedrock' | 'pi',
+) {
+  if (!Array.isArray(values)) throw new Error('Provider tool inventory missing');
+  const actual: string[] = [];
+  for (const value of values) {
+    const tool = object(value);
+    if (kind === 'google') {
+      if (
+        Object.keys(tool).some((key) => key !== 'functionDeclarations') ||
+        !Array.isArray(tool.functionDeclarations)
+      )
+        throw new Error('Provider server tools disabled');
+      actual.push(...tool.functionDeclarations.map((entry) => String(object(entry).name)));
+    } else if (kind === 'bedrock') {
+      if (Object.keys(tool).some((key) => key !== 'toolSpec'))
+        throw new Error('Provider server tools disabled');
+      actual.push(String(object(tool.toolSpec).name));
+    } else if (kind === 'function') {
+      if (tool.type !== 'function') throw new Error('Provider server tools disabled');
+      actual.push(String(tool.name ?? object(tool.function).name));
+    } else actual.push(String(tool.name));
+  }
+  if (canonical(actual.sort()) !== canonical([...names].sort()))
+    throw new Error('Unapproved provider tool inventory');
+}
+function lastText(messages: unknown, frame: string, parts: string, role = 'user') {
+  if (!Array.isArray(messages) || !messages.length) throw new Error('Provider messages missing');
+  const last = object(messages.at(-1));
+  const content = last[parts];
+  const blocks = Array.isArray(content)
+    ? content.filter(
+        (block) => !(Object.keys(object(block)).length === 1 && object(block).cachePoint),
+      )
+    : [];
+  const text =
+    typeof content === 'string' ? content : blocks.length ? object(blocks.at(-1)).text : undefined;
+  if (last.role !== role || text !== frame)
+    throw new Error('Required task context missing from provider payload');
+}
+/** Validate the API-specific payload after extension hooks. No hosted tools or hidden continuations. */
+export function validateProviderPayload(
+  value: unknown,
+  route: ProviderRoute,
+  frame: string,
+  tools: string[],
+  allowUncapped = false,
+) {
+  const p = object(value),
+    api = getProviderModel(route)?.api;
+  keys(p, allowedFields[String(api)] ?? []);
+  for (const key of [
+    'fallbacks',
+    'fallback_models',
+    'models',
+    'route',
+    'mcp_servers',
+    'container',
+    'context_management',
+    'previous_response_id',
+    'conversation',
+    'background',
+    'environment',
+    'agents',
+    'built_in_tools',
+    'cachedContent',
+  ])
+    if (p[key] !== undefined && p[key] !== false)
+      throw new Error('Unsupported provider execution feature');
+  const deployment =
+    route.provider === 'azure'
+      ? (route.connection?.configuration.AZURE_OPENAI_DEPLOYMENT_NAME_MAP?.split(',')
+          .map((entry) => entry.trim().split('='))
+          .find(([id]) => id === route.model)?.[1]
+          ?.trim() ?? route.model)
+      : route.model;
+  if (api === 'anthropic-messages') return validateClaudePayload(p, route, frame, tools);
+  if (api === 'google-generative-ai' || api === 'google-vertex') {
+    if (p.model !== deployment) throw new Error('Unapproved provider model');
+    const config = object(p.config);
+    keys(config, [
+      'maxOutputTokens',
+      'temperature',
+      'topP',
+      'topK',
+      'systemInstruction',
+      'tools',
+      'toolConfig',
+      'thinkingConfig',
+      'abortSignal',
+      'httpOptions',
+    ]);
+    if (
+      config.httpOptions !== undefined &&
+      canonical(config.httpOptions) !==
+        canonical({ retryOptions: { attempts: 1 }, timeout: 120000 })
+    )
+      throw new Error('Unapproved Google HTTP controls');
+    for (const key of ['cachedContent', 'automaticFunctionCalling', 'responseModalities'])
+      if (config[key] !== undefined) throw new Error('Unsupported Google execution feature');
+    cap(config.maxOutputTokens, route);
+    lastText(p.contents, frame, 'parts');
+    inventory(config.tools ?? [], tools, 'google');
+  } else if (api === 'bedrock-converse-stream') {
+    if (p.modelId !== route.model) throw new Error('Unapproved provider model');
+    keys(object(p.inferenceConfig), ['maxTokens', 'temperature', 'topP', 'stopSequences']);
+    keys(object(p.additionalModelRequestFields ?? {}), [
+      'thinking',
+      'reasoningConfig',
+      'reasoning_effort',
+      'reasoning',
+      'output_config',
+      'anthropic_beta',
+    ]);
+    cap(object(p.inferenceConfig).maxTokens, route);
+    lastText(p.messages, frame, 'content');
+    inventory(object(p.toolConfig).tools ?? [], tools, 'bedrock');
+    if (p.guardrailConfig || p.promptVariables || p.performanceConfig)
+      throw new Error('Unsupported Bedrock execution feature');
+  } else if (api === 'pi-messages') {
+    if (p.model !== deployment) throw new Error('Unapproved provider model');
+    keys(object(p.options), [
+      'temperature',
+      'maxTokens',
+      'reasoning',
+      'cacheRetention',
+      'sessionId',
+      'toolChoice',
+    ]);
+    cap(object(p.options).maxTokens, route);
+    const context = object(p.context);
+    lastText(context.messages, frame, 'content');
+    inventory(getCurrentTools((context as unknown as TranscriptContext).messages), tools, 'pi');
+  } else if (
+    ['openai-responses', 'azure-openai-responses', 'openai-codex-responses'].includes(String(api))
+  ) {
+    if (p.model !== deployment) throw new Error('Unapproved provider model');
+    if (p.stream !== true) throw new Error('Provider streaming required');
+    if (!allowUncapped || p.max_output_tokens !== undefined) cap(p.max_output_tokens, route);
+    lastText(p.input, frame, 'content');
+    inventory(p.tools ?? [], tools, 'function');
+    if (p.store !== false) throw new Error('Provider storage disabled');
+  } else if (api === 'openai-completions' || api === 'mistral-conversations') {
+    if (p.model !== deployment || p.stream !== true) throw new Error('Unapproved provider model');
+    cap(p.max_completion_tokens ?? p.max_tokens ?? p.maxTokens, route);
+    lastText(p.messages, frame, 'content');
+    inventory(p.tools ?? [], tools, 'function');
+  } else throw new Error('Unsupported provider chat API');
+}

package/src/provider-transport.ts

@@ -0,0 +1,51 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { BedrockRuntimeClient } from '@aws-sdk/client-bedrock-runtime';
+
+export interface ProviderTransport {
+  fetch(input: string | URL | Request, init?: RequestInit): Promise<Response>;
+  bedrock(request: {
+    protocol: string;
+    hostname: string;
+    path: string;
+    method: string;
+    body?: unknown;
+    headers: Record<string, string>;
+  }): Promise<void>;
+}
+const scope = new AsyncLocalStorage<ProviderTransport>();
+let installed = false;
+let underlyingFetch: typeof globalThis.fetch;
+/** Worker-local SDK interception, scoped to the active model call (not auth refresh). */
+export function installProviderTransport() {
+  if (installed) return underlyingFetch;
+  installed = true;
+  const originalFetch = (underlyingFetch = globalThis.fetch);
+  globalThis.fetch = (input, init) =>
+    scope.getStore()?.fetch(input, init) ??
+    Promise.reject(new Error('Unadmitted worker network request'));
+  const send = BedrockRuntimeClient.prototype.send;
+  BedrockRuntimeClient.prototype.send = function (
+    this: BedrockRuntimeClient,
+    ...args: Parameters<typeof send>
+  ) {
+    const gate = scope.getStore();
+    if (gate) {
+      // Pi 1.3.0 doesn't forward maxRetries to this SDK. Disable SDK retries explicitly.
+      this.config.retryStrategy = async () => ({
+        mode: 'standard',
+        retry: async (next, request) => next(request),
+      });
+      const handler = this.config.requestHandler;
+      const handle = handler.handle.bind(handler);
+      handler.handle = async (request, options) => {
+        await gate.bedrock(request);
+        return handle(request, options);
+      };
+    }
+    return Reflect.apply(send, this, args);
+  } as typeof send;
+  return originalFetch;
+}
+export function withProviderTransport<T>(transport: ProviderTransport, fn: () => T): T {
+  return scope.run(transport, fn);
+}

package/src/provider-usage.ts

@@ -0,0 +1,64 @@
+import type { Api } from '@earendil-works/pi-ai';
+
+function record(value: unknown): Record<string, unknown> {
+  return typeof value === 'object' && value !== null ? (value as Record<string, unknown>) : {};
+}
+const token = (value: unknown) =>
+  typeof value === 'number' && Number.isSafeInteger(value) && value >= 0;
+/** A normalized zero is not evidence that a provider reported zero usage. */
+export class ProviderUsageReceipt {
+  private input = false;
+  private output = false;
+  observe(api: Api, value: unknown) {
+    const event = record(value);
+    let input: unknown, output: unknown;
+    switch (api) {
+      case 'anthropic-messages': {
+        const usage = record(
+          event.type === 'message_start' ? record(event.message).usage : event.usage,
+        );
+        input = usage.input_tokens;
+        output = event.type === 'message_delta' ? usage.output_tokens : undefined;
+        break;
+      }
+      case 'google-generative-ai':
+      case 'google-vertex': {
+        const usage = record(event.usageMetadata);
+        input = usage.promptTokenCount;
+        output = usage.candidatesTokenCount;
+        break;
+      }
+      case 'bedrock-converse-stream': {
+        const usage = record(record(event.metadata).usage);
+        input = usage.inputTokens;
+        output = usage.outputTokens;
+        break;
+      }
+      case 'openai-responses':
+      case 'azure-openai-responses':
+      case 'openai-codex-responses': {
+        const usage = record(record(event.response).usage);
+        input = usage.input_tokens;
+        output = usage.output_tokens;
+        break;
+      }
+      case 'pi-messages': {
+        const usage = record(event.usage);
+        input = usage.input;
+        output = usage.output;
+        break;
+      }
+      default: {
+        const usage = record(event.usage);
+        input = usage.prompt_tokens ?? usage.promptTokens;
+        output = usage.completion_tokens ?? usage.completionTokens;
+        break;
+      }
+    }
+    this.input ||= token(input);
+    this.output ||= token(output);
+  }
+  get complete() {
+    return this.input && this.output;
+  }
+}