@purista/harness-azure-foundry 1.0.0

package/LICENSE

@@ -0,0 +1,4 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+

package/README.md

@@ -0,0 +1,27 @@
+# @purista/harness-azure-foundry
+
+Azure AI Foundry model provider adapter for `@purista/harness`.
+
+## Install
+
+```bash
+npm install @purista/harness @purista/harness-azure-foundry
+```
+
+Configure the provider with an Azure AI Foundry model endpoint and either an API
+key or Azure credential.
+
+```ts
+import { azureFoundry } from '@purista/harness-azure-foundry'
+
+azureFoundry({
+  endpoint: process.env.AZURE_AI_ENDPOINT!,
+  apiKey: process.env.AZURE_AI_API_KEY!
+})
+```
+
+## Package Format
+
+This package is ESM-only and ships compiled JavaScript plus TypeScript
+declarations from `dist/`. Source files, tests, source maps, and local configs
+are not included in the published package.

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import type { BaseModelProviderOptions, ModelProvider } from '@purista/harness';
+import { type ModelClientOptions } from '@azure-rest/ai-inference';
+import { type KeyCredential, type TokenCredential } from '@azure/core-auth';
+export interface AzureFoundryFactoryOptions extends ModelClientOptions {
+    /** Azure AI Foundry model endpoint. Not required when `client` is injected. */
+    endpoint?: string;
+    /** Azure AI Foundry API key. Ignored when `credential` or `client` is provided. */
+    apiKey?: string;
+    /** Azure credential, for example `DefaultAzureCredential`. */
+    credential?: TokenCredential | KeyCredential;
+    /** Optional injected client for tests or custom transport behavior. */
+    client?: AzureFoundryClient;
+    /** Optional adapter-level logger override. Defaults to the harness logger when registered. */
+    harnessLogger?: BaseModelProviderOptions['logger'];
+    /** Optional adapter-level telemetry override. Defaults to the harness telemetry shim when registered. */
+    telemetry?: BaseModelProviderOptions['telemetry'];
+    /** Optional adapter-level timeout override. Defaults to the harness model timeout when registered. */
+    harnessTimeoutMs?: number;
+}
+/**
+ * Creates an Azure AI Foundry-backed harness `ModelProvider`.
+ *
+ * @example
+ * ```ts
+ * import { azureFoundry } from '@purista/harness-azure-foundry'
+ *
+ * const provider = azureFoundry({
+ *   endpoint: process.env.AZURE_AI_ENDPOINT,
+ *   apiKey: process.env.AZURE_AI_API_KEY
+ * })
+ * ```
+ */
+export declare function azureFoundry(options?: AzureFoundryFactoryOptions): ModelProvider;
+export type AzureFoundryClient = {
+    path(path: '/chat/completions' | '/embeddings'): {
+        post(options: unknown): Promise<any> & {
+            asNodeStream?: () => Promise<any>;
+        };
+    };
+};

package/dist/index.js

@@ -0,0 +1,324 @@
+import { BaseModelProvider, ModelError } from '@purista/harness';
+import ModelClient, {} from '@azure-rest/ai-inference';
+import { AzureKeyCredential } from '@azure/core-auth';
+import { createSseStream } from '@azure/core-sse';
+/**
+ * Creates an Azure AI Foundry-backed harness `ModelProvider`.
+ *
+ * @example
+ * ```ts
+ * import { azureFoundry } from '@purista/harness-azure-foundry'
+ *
+ * const provider = azureFoundry({
+ *   endpoint: process.env.AZURE_AI_ENDPOINT,
+ *   apiKey: process.env.AZURE_AI_API_KEY
+ * })
+ * ```
+ */
+export function azureFoundry(options = {}) {
+    return new AzureFoundryModelProvider(options);
+}
+class AzureFoundryModelProvider extends BaseModelProvider {
+    options;
+    client;
+    constructor(options) {
+        super({
+            id: 'azure-foundry',
+            genAiSystem: 'azure.ai.inference',
+            ...(options.harnessLogger ? { logger: options.harnessLogger } : {}),
+            ...(options.telemetry ? { telemetry: options.telemetry } : {}),
+            ...(options.harnessTimeoutMs !== undefined ? { timeoutMs: options.harnessTimeoutMs } : {})
+        });
+        this.options = options;
+        this.client = options.client ?? createClient(options);
+    }
+    async doText(req) {
+        req.signal.throwIfAborted();
+        const response = await postChat(this.client, req, false);
+        const body = ensureOk(response);
+        const choice = body.choices?.[0];
+        const toolCalls = extractToolCalls(choice?.message?.tool_calls, req, 'text');
+        return {
+            content: choice?.message?.content ?? '',
+            ...(toolCalls ? { toolCalls } : {}),
+            usage: toUsage(body.usage?.prompt_tokens, body.usage?.completion_tokens, body.usage?.total_tokens),
+            finishReason: toFinishReason(choice?.finish_reason),
+            raw: response
+        };
+    }
+    async *doTextStream(req) {
+        req.signal.throwIfAborted();
+        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let finishReason = 'stop';
+        for await (const event of streamChat(this.client, req, false)) {
+            req.signal.throwIfAborted();
+            const data = parseStreamData(event, req, 'textStream');
+            if (!data)
+                continue;
+            for (const choice of data.choices ?? []) {
+                if (choice.delta?.content) {
+                    yield { kind: 'delta', text: choice.delta.content };
+                }
+                const toolCalls = extractToolCalls(choice.delta?.tool_calls, req, 'textStream');
+                for (const call of toolCalls ?? []) {
+                    yield { kind: 'tool_call', call };
+                }
+                finishReason = toFinishReason(choice.finish_reason ?? finishReason);
+            }
+            if (data.usage) {
+                usage = toUsage(data.usage.prompt_tokens, data.usage.completion_tokens, data.usage.total_tokens);
+            }
+        }
+        yield { kind: 'finish', usage, finishReason };
+    }
+    async doObject(req) {
+        req.signal.throwIfAborted();
+        const response = await postChat(this.client, req, false);
+        const body = ensureOk(response);
+        const choice = body.choices?.[0];
+        const text = choice?.message?.content ?? '{}';
+        const toolCalls = extractToolCalls(choice?.message?.tool_calls, req, 'object');
+        return {
+            object: parseJson(text, req, 'object'),
+            ...(toolCalls ? { toolCalls } : {}),
+            usage: toUsage(body.usage?.prompt_tokens, body.usage?.completion_tokens, body.usage?.total_tokens),
+            finishReason: toFinishReason(choice?.finish_reason),
+            raw: response
+        };
+    }
+    async *doObjectStream(req) {
+        req.signal.throwIfAborted();
+        let partial = '';
+        let usage = { inputTokens: 0, outputTokens: 0, totalTokens: 0 };
+        let finishReason = 'stop';
+        for await (const event of streamChat(this.client, req, true)) {
+            req.signal.throwIfAborted();
+            const data = parseStreamData(event, req, 'objectStream');
+            if (!data)
+                continue;
+            for (const choice of data.choices ?? []) {
+                if (choice.delta?.content) {
+                    partial += choice.delta.content;
+                    yield { kind: 'partial', partial: safePartialJson(partial) };
+                }
+                const toolCalls = extractToolCalls(choice.delta?.tool_calls, req, 'objectStream');
+                for (const call of toolCalls ?? []) {
+                    yield { kind: 'tool_call', call };
+                }
+                finishReason = toFinishReason(choice.finish_reason ?? finishReason);
+            }
+            if (data.usage) {
+                usage = toUsage(data.usage.prompt_tokens, data.usage.completion_tokens, data.usage.total_tokens);
+            }
+        }
+        const object = parseJson(partial || '{}', req, 'objectStream');
+        yield { kind: 'finish', object, usage, finishReason };
+    }
+    async doEmbed(req) {
+        req.signal.throwIfAborted();
+        const providerOptions = {
+            ...(req.call?.providerOptions ?? {})
+        };
+        const { requestOptions, ...bodyOptions } = providerOptions;
+        const response = await this.client.path('/embeddings').post({
+            body: {
+                model: req.model,
+                input: Array.isArray(req.input) ? [...req.input] : [req.input],
+                ...(req.dimensions !== undefined ? { dimensions: req.dimensions } : {}),
+                ...bodyOptions
+            },
+            ...requestOptions,
+            abortSignal: req.signal
+        });
+        const body = ensureOk(response);
+        return {
+            embeddings: body.data.map((item) => ({
+                index: item.index,
+                vector: Array.isArray(item.embedding) ? item.embedding : []
+            })),
+            usage: toUsage(body.usage?.prompt_tokens, 0, body.usage?.total_tokens),
+            raw: response
+        };
+    }
+}
+function createClient(options) {
+    const { endpoint, apiKey, credential, client: _client, harnessLogger: _harnessLogger, telemetry: _telemetry, harnessTimeoutMs: _harnessTimeoutMs, ...clientOptions } = options;
+    if (!endpoint) {
+        throw new Error('Azure AI Foundry endpoint is required when no client is injected.');
+    }
+    const auth = credential ?? (apiKey ? new AzureKeyCredential(apiKey) : undefined);
+    if (!auth) {
+        throw new Error('Azure AI Foundry apiKey or credential is required when no client is injected.');
+    }
+    return ModelClient(endpoint, auth, clientOptions);
+}
+async function postChat(client, req, stream) {
+    const providerOptions = {
+        ...(req.defaults?.providerOptions ?? {}),
+        ...(req.call?.providerOptions ?? {})
+    };
+    const { requestOptions, ...bodyOptions } = providerOptions;
+    return client.path('/chat/completions').post({
+        body: {
+            model: req.model,
+            messages: toAzureMessages(req.messages),
+            stream,
+            tools: toTools(req.tools),
+            temperature: req.call?.temperature ?? req.defaults?.temperature,
+            max_tokens: req.call?.maxTokens ?? req.defaults?.maxTokens,
+            top_p: req.call?.topP ?? req.defaults?.topP,
+            stop: req.call?.stopSequences ?? req.defaults?.stopSequences,
+            response_format: toResponseFormat(req),
+            ...bodyOptions
+        },
+        ...requestOptions,
+        abortSignal: req.signal
+    });
+}
+async function* streamChat(client, req, objectMode) {
+    const response = await postChat(client, req, true);
+    const nodeResponse = typeof response.asNodeStream === 'function' ? await response.asNodeStream() : response;
+    if (nodeResponse.status && nodeResponse.status !== '200' && nodeResponse.status !== 200) {
+        throw nodeResponse.body?.error ?? new Error('Azure AI Foundry streaming request failed.');
+    }
+    if (nodeResponse.body?.[Symbol.asyncIterator]) {
+        const sses = createSseStream(nodeResponse.body);
+        for await (const event of sses) {
+            if (event.data === '[DONE]')
+                break;
+            yield event.data;
+        }
+        return;
+    }
+    for await (const event of nodeResponse.body ?? []) {
+        yield event;
+    }
+}
+function ensureOk(response) {
+    if (response.status && response.status !== '200' && response.status !== 200) {
+        throw response.body?.error ?? new Error('Azure AI Foundry request failed.');
+    }
+    return response.body ?? response;
+}
+function toAzureMessages(messages) {
+    return messages.map((message) => {
+        if (message.role === 'assistant' && message.toolCalls && message.toolCalls.length > 0) {
+            return {
+                role: 'assistant',
+                content: typeof message.content === 'string' ? message.content : '',
+                tool_calls: message.toolCalls.map((call) => ({
+                    id: call.id,
+                    type: 'function',
+                    function: {
+                        name: call.name,
+                        arguments: JSON.stringify(call.arguments)
+                    }
+                }))
+            };
+        }
+        if (message.role === 'tool') {
+            return { role: 'tool', tool_call_id: message.toolCallId, content: message.content };
+        }
+        return {
+            role: message.role,
+            content: typeof message.content === 'string' ? message.content : message.content.map(toContentItem)
+        };
+    });
+}
+function toContentItem(part) {
+    if (part.kind === 'text')
+        return { type: 'text', text: part.text };
+    if (part.kind === 'image')
+        return { type: 'image_url', image_url: { url: `data:${part.mimeType};base64,${part.dataBase64}` } };
+    if (part.kind === 'image_url')
+        return { type: 'image_url', image_url: { url: part.url } };
+    if (part.kind === 'audio')
+        return { type: 'input_audio', input_audio: { data: part.dataBase64, format: part.mimeType.split('/')[1] ?? 'wav' } };
+    return { type: 'text', text: `[unsupported ${part.kind} content omitted]` };
+}
+function toTools(tools) {
+    if (!tools || tools.length === 0)
+        return undefined;
+    return tools.map((tool) => ({
+        type: 'function',
+        function: {
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.parameters
+        }
+    }));
+}
+function toResponseFormat(req) {
+    if (!('schema' in req))
+        return undefined;
+    return {
+        type: 'json_schema',
+        json_schema: {
+            name: req.schemaName ?? 'harness_response',
+            strict: false,
+            schema: req.schema
+        }
+    };
+}
+function extractToolCalls(toolCalls, req, method) {
+    if (!Array.isArray(toolCalls) || toolCalls.length === 0)
+        return undefined;
+    return toolCalls
+        .filter((call) => call?.id && call?.function?.name)
+        .map((call) => ({
+        id: String(call.id),
+        name: String(call.function.name),
+        arguments: parseJson(call.function.arguments ?? '{}', req, method)
+    }));
+}
+function parseStreamData(event, req, method) {
+    if (event === '[DONE]')
+        return undefined;
+    if (typeof event === 'string')
+        return parseJson(event, req, method);
+    return event;
+}
+function parseJson(content, req, method) {
+    try {
+        return JSON.parse(content);
+    }
+    catch (error) {
+        throw malformedResponseError(req, method, 'Azure AI Foundry returned malformed JSON.', content, error);
+    }
+}
+function malformedResponseError(req, method, message, body, cause) {
+    return new ModelError(message, {
+        provider: 'azure-foundry',
+        model: req.model,
+        method,
+        reason: 'malformed_response',
+        providerBody: body
+    }, cause);
+}
+function safePartialJson(content) {
+    try {
+        return JSON.parse(content);
+    }
+    catch {
+        return { _partial: content };
+    }
+}
+function toUsage(inputTokens, outputTokens, totalTokens) {
+    const input = inputTokens ?? 0;
+    const output = outputTokens ?? 0;
+    return { inputTokens: input, outputTokens: output, totalTokens: totalTokens ?? input + output };
+}
+function toFinishReason(value) {
+    switch (value) {
+        case 'stop':
+            return 'stop';
+        case 'length':
+            return 'length';
+        case 'tool_calls':
+            return 'tool_calls';
+        case 'content_filter':
+            return 'content_filter';
+        default:
+            return 'error';
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@purista/harness-azure-foundry",
+  "version": "1.0.0",
+  "description": "Azure AI Foundry model provider adapter for @purista/harness.",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "package.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "license": "Apache-2.0",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/puristajs/harness",
+    "directory": "packages/harness-azure-foundry"
+  },
+  "bugs": {
+    "url": "https://github.com/puristajs/harness/issues"
+  },
+  "homepage": "https://github.com/puristajs/harness#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "test": "vitest run",
+    "lint": "echo 'no lint configured for @purista/harness-azure-foundry'"
+  },
+  "dependencies": {
+    "@azure-rest/ai-inference": "^1.0.0-beta.6",
+    "@azure/core-auth": "^1.10.1",
+    "@azure/core-sse": "^2.3.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^4.1.5",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.5"
+  },
+  "peerDependencies": {
+    "@purista/harness": "*"
+  },
+  "engines": {
+    "node": ">=24.15.0"
+  }
+}