@providerprotocol/ai 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025, 2026 ProviderProtocol
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# @providerprotocol/ai
+
+Unified Provider Protocol (UPP-1.1) implementation for AI inference across multiple providers.
+
+## Install
+
+```bash
+bun add @providerprotocol/ai
+```
+
+## Usage
+
+```typescript
+import { llm } from '@providerprotocol/ai';
+import { anthropic } from '@providerprotocol/ai/anthropic';
+import { openai } from '@providerprotocol/ai/openai';
+import { google } from '@providerprotocol/ai/google';
+
+// Simple generation
+const claude = llm({ model: anthropic('claude-sonnet-4-20250514') });
+const turn = await claude.generate('Hello!');
+console.log(turn.response.text);
+
+// Streaming
+const stream = claude.stream('Count to 5');
+for await (const event of stream) {
+  if (event.type === 'text_delta') process.stdout.write(event.delta.text);
+}
+
+// Multi-turn
+const history = [];
+const t1 = await claude.generate(history, 'My name is Alice');
+history.push(...t1.messages);
+const t2 = await claude.generate(history, 'What is my name?');
+
+// Tools
+const turn = await claude.generate({
+  tools: [{
+    name: 'getWeather',
+    description: 'Get weather for a location',
+    parameters: { type: 'object', properties: { location: { type: 'string' } } },
+    run: async ({ location }) => `Sunny in ${location}`,
+  }],
+}, 'Weather in Tokyo?');
+
+// Structured output
+const turn = await llm({
+  model: openai('gpt-4o'),
+  structure: {
+    type: 'object',
+    properties: { name: { type: 'string' }, age: { type: 'number' } },
+  },
+}).generate('Extract: John is 30 years old');
+console.log(turn.data); // { name: 'John', age: 30 }
+```
+
+## Providers
+
+| Provider | Import |
+|----------|--------|
+| Anthropic | `@providerprotocol/ai/anthropic` |
+| OpenAI | `@providerprotocol/ai/openai` |
+| Google | `@providerprotocol/ai/google` |
+
+## Configuration
+
+```typescript
+import { ExponentialBackoff, RoundRobinKeys } from '@providerprotocol/ai/http';
+
+const instance = llm({
+  model: openai('gpt-4o'),
+  config: {
+    apiKey: 'sk-...',
+    timeout: 30000,
+    retryStrategy: new ExponentialBackoff({ maxAttempts: 3 }),
+  },
+  params: { temperature: 0.7, max_tokens: 1000 },
+  system: 'You are helpful.',
+});
+```
+
+## License
+
+MIT

package/dist/anthropic/index.d.ts

@@ -0,0 +1,41 @@
+import { b as Provider } from '../provider-CUJWjgNl.js';
+
+/**
+ * Anthropic-specific LLM parameters
+ * These are passed through to the Anthropic Messages API
+ */
+interface AnthropicLLMParams {
+    /** Maximum number of tokens to generate (required by Anthropic) */
+    max_tokens: number;
+    /** Temperature for randomness (0.0 - 1.0) */
+    temperature?: number;
+    /** Top-p (nucleus) sampling */
+    top_p?: number;
+    /** Top-k sampling */
+    top_k?: number;
+    /** Custom stop sequences */
+    stop_sequences?: string[];
+    /** Metadata for the request */
+    metadata?: {
+        user_id?: string;
+    };
+    /** Extended thinking configuration */
+    thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+    };
+    /**
+     * Service tier for priority/standard capacity
+     * - "auto": Automatically select based on availability (default)
+     * - "standard_only": Only use standard capacity
+     */
+    service_tier?: 'auto' | 'standard_only';
+}
+
+/**
+ * Anthropic provider
+ * Supports LLM modality with Claude models
+ */
+declare const anthropic: Provider<unknown>;
+
+export { type AnthropicLLMParams, anthropic };

package/dist/anthropic/index.js

@@ -0,0 +1,500 @@
+import {
+  createProvider
+} from "../chunk-Y6Q7JCNP.js";
+import {
+  AssistantMessage,
+  isAssistantMessage,
+  isToolResultMessage,
+  isUserMessage
+} from "../chunk-QUUX4G7U.js";
+import {
+  UPPError,
+  doFetch,
+  doStreamFetch,
+  normalizeHttpError,
+  parseSSEStream,
+  resolveApiKey
+} from "../chunk-FTFX2VET.js";
+
+// src/providers/anthropic/transform.ts
+function transformRequest(request, modelId) {
+  const params = request.params ?? { max_tokens: 4096 };
+  const anthropicRequest = {
+    model: modelId,
+    max_tokens: params.max_tokens ?? 4096,
+    messages: request.messages.map(transformMessage)
+  };
+  if (request.system) {
+    anthropicRequest.system = request.system;
+  }
+  if (params.temperature !== void 0) {
+    anthropicRequest.temperature = params.temperature;
+  }
+  if (params.top_p !== void 0) {
+    anthropicRequest.top_p = params.top_p;
+  }
+  if (params.top_k !== void 0) {
+    anthropicRequest.top_k = params.top_k;
+  }
+  if (params.stop_sequences) {
+    anthropicRequest.stop_sequences = params.stop_sequences;
+  }
+  if (params.metadata) {
+    anthropicRequest.metadata = params.metadata;
+  }
+  if (params.thinking) {
+    anthropicRequest.thinking = params.thinking;
+  }
+  if (params.service_tier !== void 0) {
+    anthropicRequest.service_tier = params.service_tier;
+  }
+  if (request.tools && request.tools.length > 0) {
+    anthropicRequest.tools = request.tools.map(transformTool);
+    anthropicRequest.tool_choice = { type: "auto" };
+  }
+  if (request.structure) {
+    const structuredTool = {
+      name: "json_response",
+      description: "Return the response in the specified JSON format. You MUST use this tool to provide your response.",
+      input_schema: {
+        type: "object",
+        properties: request.structure.properties,
+        required: request.structure.required
+      }
+    };
+    anthropicRequest.tools = [...anthropicRequest.tools ?? [], structuredTool];
+    anthropicRequest.tool_choice = { type: "tool", name: "json_response" };
+  }
+  return anthropicRequest;
+}
+function filterValidContent(content) {
+  return content.filter((c) => c && typeof c.type === "string");
+}
+function transformMessage(message) {
+  if (isUserMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    return {
+      role: "user",
+      content: validContent.map(transformContentBlock)
+    };
+  }
+  if (isAssistantMessage(message)) {
+    const validContent = filterValidContent(message.content);
+    const content = validContent.map(transformContentBlock);
+    if (message.toolCalls) {
+      for (const call of message.toolCalls) {
+        content.push({
+          type: "tool_use",
+          id: call.toolCallId,
+          name: call.toolName,
+          input: call.arguments
+        });
+      }
+    }
+    return {
+      role: "assistant",
+      content
+    };
+  }
+  if (isToolResultMessage(message)) {
+    return {
+      role: "user",
+      content: message.results.map((result) => ({
+        type: "tool_result",
+        tool_use_id: result.toolCallId,
+        content: typeof result.result === "string" ? result.result : JSON.stringify(result.result),
+        is_error: result.isError
+      }))
+    };
+  }
+  throw new Error(`Unknown message type: ${message.type}`);
+}
+function transformContentBlock(block) {
+  switch (block.type) {
+    case "text":
+      return { type: "text", text: block.text };
+    case "image": {
+      const imageBlock = block;
+      if (imageBlock.source.type === "base64") {
+        return {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: imageBlock.mimeType,
+            data: imageBlock.source.data
+          }
+        };
+      }
+      if (imageBlock.source.type === "url") {
+        return {
+          type: "image",
+          source: {
+            type: "url",
+            url: imageBlock.source.url
+          }
+        };
+      }
+      if (imageBlock.source.type === "bytes") {
+        const base64 = btoa(
+          Array.from(imageBlock.source.data).map((b) => String.fromCharCode(b)).join("")
+        );
+        return {
+          type: "image",
+          source: {
+            type: "base64",
+            media_type: imageBlock.mimeType,
+            data: base64
+          }
+        };
+      }
+      throw new Error(`Unknown image source type`);
+    }
+    default:
+      throw new Error(`Unsupported content type: ${block.type}`);
+  }
+}
+function transformTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: {
+      type: "object",
+      properties: tool.parameters.properties,
+      required: tool.parameters.required
+    }
+  };
+}
+function transformResponse(data) {
+  const textContent = [];
+  const toolCalls = [];
+  let structuredData;
+  for (const block of data.content) {
+    if (block.type === "text") {
+      textContent.push({ type: "text", text: block.text });
+    } else if (block.type === "tool_use") {
+      if (block.name === "json_response") {
+        structuredData = block.input;
+      }
+      toolCalls.push({
+        toolCallId: block.id,
+        toolName: block.name,
+        arguments: block.input
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: data.id,
+      metadata: {
+        anthropic: {
+          stop_reason: data.stop_reason,
+          stop_sequence: data.stop_sequence,
+          model: data.model
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: data.usage.input_tokens,
+    outputTokens: data.usage.output_tokens,
+    totalTokens: data.usage.input_tokens + data.usage.output_tokens
+  };
+  return {
+    message,
+    usage,
+    stopReason: data.stop_reason ?? "end_turn",
+    data: structuredData
+  };
+}
+function createStreamState() {
+  return {
+    messageId: "",
+    model: "",
+    content: [],
+    stopReason: null,
+    inputTokens: 0,
+    outputTokens: 0
+  };
+}
+function transformStreamEvent(event, state) {
+  switch (event.type) {
+    case "message_start":
+      state.messageId = event.message.id;
+      state.model = event.message.model;
+      state.inputTokens = event.message.usage.input_tokens;
+      return { type: "message_start", index: 0, delta: {} };
+    case "content_block_start":
+      if (event.content_block.type === "text") {
+        state.content[event.index] = { type: "text", text: "" };
+      } else if (event.content_block.type === "tool_use") {
+        state.content[event.index] = {
+          type: "tool_use",
+          id: event.content_block.id,
+          name: event.content_block.name,
+          input: ""
+        };
+      }
+      return { type: "content_block_start", index: event.index, delta: {} };
+    case "content_block_delta": {
+      const delta = event.delta;
+      if (delta.type === "text_delta") {
+        if (state.content[event.index]) {
+          state.content[event.index].text = (state.content[event.index].text ?? "") + delta.text;
+        }
+        return {
+          type: "text_delta",
+          index: event.index,
+          delta: { text: delta.text }
+        };
+      }
+      if (delta.type === "input_json_delta") {
+        if (state.content[event.index]) {
+          state.content[event.index].input = (state.content[event.index].input ?? "") + delta.partial_json;
+        }
+        return {
+          type: "tool_call_delta",
+          index: event.index,
+          delta: {
+            argumentsJson: delta.partial_json,
+            toolCallId: state.content[event.index]?.id,
+            toolName: state.content[event.index]?.name
+          }
+        };
+      }
+      if (delta.type === "thinking_delta") {
+        return {
+          type: "reasoning_delta",
+          index: event.index,
+          delta: { text: delta.thinking }
+        };
+      }
+      return null;
+    }
+    case "content_block_stop":
+      return { type: "content_block_stop", index: event.index, delta: {} };
+    case "message_delta":
+      state.stopReason = event.delta.stop_reason;
+      state.outputTokens = event.usage.output_tokens;
+      return null;
+    case "message_stop":
+      return { type: "message_stop", index: 0, delta: {} };
+    case "ping":
+    case "error":
+      return null;
+    default:
+      return null;
+  }
+}
+function buildResponseFromState(state) {
+  const textContent = [];
+  const toolCalls = [];
+  let structuredData;
+  for (const block of state.content) {
+    if (block.type === "text" && block.text) {
+      textContent.push({ type: "text", text: block.text });
+    } else if (block.type === "tool_use" && block.id && block.name) {
+      let args = {};
+      if (block.input) {
+        try {
+          args = JSON.parse(block.input);
+        } catch {
+        }
+      }
+      if (block.name === "json_response") {
+        structuredData = args;
+      }
+      toolCalls.push({
+        toolCallId: block.id,
+        toolName: block.name,
+        arguments: args
+      });
+    }
+  }
+  const message = new AssistantMessage(
+    textContent,
+    toolCalls.length > 0 ? toolCalls : void 0,
+    {
+      id: state.messageId,
+      metadata: {
+        anthropic: {
+          stop_reason: state.stopReason,
+          model: state.model
+        }
+      }
+    }
+  );
+  const usage = {
+    inputTokens: state.inputTokens,
+    outputTokens: state.outputTokens,
+    totalTokens: state.inputTokens + state.outputTokens
+  };
+  return {
+    message,
+    usage,
+    stopReason: state.stopReason ?? "end_turn",
+    data: structuredData
+  };
+}
+
+// src/providers/anthropic/llm.ts
+var ANTHROPIC_API_URL = "https://api.anthropic.com/v1/messages";
+var ANTHROPIC_VERSION = "2023-06-01";
+var ANTHROPIC_CAPABILITIES = {
+  streaming: true,
+  tools: true,
+  structuredOutput: true,
+  imageInput: true,
+  videoInput: false,
+  audioInput: false
+};
+function createLLMHandler() {
+  let providerRef = null;
+  return {
+    _setProvider(provider) {
+      providerRef = provider;
+    },
+    bind(modelId) {
+      if (!providerRef) {
+        throw new UPPError(
+          "Provider reference not set. Handler must be used with createProvider().",
+          "INVALID_REQUEST",
+          "anthropic",
+          "llm"
+        );
+      }
+      const model = {
+        modelId,
+        capabilities: ANTHROPIC_CAPABILITIES,
+        get provider() {
+          return providerRef;
+        },
+        async complete(request) {
+          const apiKey = await resolveApiKey(
+            request.config,
+            "ANTHROPIC_API_KEY",
+            "anthropic",
+            "llm"
+          );
+          const baseUrl = request.config.baseUrl ?? ANTHROPIC_API_URL;
+          const body = transformRequest(request, modelId);
+          const response = await doFetch(
+            baseUrl,
+            {
+              method: "POST",
+              headers: {
+                "Content-Type": "application/json",
+                "x-api-key": apiKey,
+                "anthropic-version": request.config.apiVersion ?? ANTHROPIC_VERSION
+              },
+              body: JSON.stringify(body),
+              signal: request.signal
+            },
+            request.config,
+            "anthropic",
+            "llm"
+          );
+          const data = await response.json();
+          return transformResponse(data);
+        },
+        stream(request) {
+          const state = createStreamState();
+          let responseResolve;
+          let responseReject;
+          const responsePromise = new Promise((resolve, reject) => {
+            responseResolve = resolve;
+            responseReject = reject;
+          });
+          async function* generateEvents() {
+            try {
+              const apiKey = await resolveApiKey(
+                request.config,
+                "ANTHROPIC_API_KEY",
+                "anthropic",
+                "llm"
+              );
+              const baseUrl = request.config.baseUrl ?? ANTHROPIC_API_URL;
+              const body = transformRequest(request, modelId);
+              body.stream = true;
+              const response = await doStreamFetch(
+                baseUrl,
+                {
+                  method: "POST",
+                  headers: {
+                    "Content-Type": "application/json",
+                    "x-api-key": apiKey,
+                    "anthropic-version": request.config.apiVersion ?? ANTHROPIC_VERSION
+                  },
+                  body: JSON.stringify(body),
+                  signal: request.signal
+                },
+                request.config,
+                "anthropic",
+                "llm"
+              );
+              if (!response.ok) {
+                const error = await normalizeHttpError(response, "anthropic", "llm");
+                responseReject(error);
+                throw error;
+              }
+              if (!response.body) {
+                const error = new UPPError(
+                  "No response body for streaming request",
+                  "PROVIDER_ERROR",
+                  "anthropic",
+                  "llm"
+                );
+                responseReject(error);
+                throw error;
+              }
+              for await (const data of parseSSEStream(response.body)) {
+                if (typeof data === "object" && data !== null && "type" in data) {
+                  const event = data;
+                  if (event.type === "error") {
+                    const error = new UPPError(
+                      event.error.message,
+                      "PROVIDER_ERROR",
+                      "anthropic",
+                      "llm"
+                    );
+                    responseReject(error);
+                    throw error;
+                  }
+                  const uppEvent = transformStreamEvent(event, state);
+                  if (uppEvent) {
+                    yield uppEvent;
+                  }
+                }
+              }
+              responseResolve(buildResponseFromState(state));
+            } catch (error) {
+              responseReject(error);
+              throw error;
+            }
+          }
+          return {
+            [Symbol.asyncIterator]() {
+              return generateEvents();
+            },
+            response: responsePromise
+          };
+        }
+      };
+      return model;
+    }
+  };
+}
+
+// src/providers/anthropic/index.ts
+var anthropic = createProvider({
+  name: "anthropic",
+  version: "1.0.0",
+  modalities: {
+    llm: createLLMHandler()
+  }
+});
+export {
+  anthropic
+};
+//# sourceMappingURL=index.js.map