@nexface/agent 0.1.1-alpha.0

package/dist/models/885.js

@@ -0,0 +1,630 @@
+import { defineAgentModelConfig } from "../model/binding.js";
+
+// Generic event stream class for async iteration
+class EventStream {
+    queue = [];
+    waiting = [];
+    done = false;
+    finalResultPromise;
+    resolveFinalResult;
+    isComplete;
+    extractResult;
+    constructor(isComplete, extractResult) {
+        this.isComplete = isComplete;
+        this.extractResult = extractResult;
+        this.finalResultPromise = new Promise((resolve) => {
+            this.resolveFinalResult = resolve;
+        });
+    }
+    push(event) {
+        if (this.done)
+            return;
+        if (this.isComplete(event)) {
+            this.done = true;
+            this.resolveFinalResult(this.extractResult(event));
+        }
+        // Deliver to waiting consumer or queue it
+        const waiter = this.waiting.shift();
+        if (waiter) {
+            waiter({ value: event, done: false });
+        }
+        else {
+            this.queue.push(event);
+        }
+    }
+    end(result) {
+        this.done = true;
+        if (result !== undefined) {
+            this.resolveFinalResult(result);
+        }
+        // Notify all waiting consumers that we're done
+        while (this.waiting.length > 0) {
+            const waiter = this.waiting.shift();
+            waiter({ value: undefined, done: true });
+        }
+    }
+    async *[Symbol.asyncIterator]() {
+        while (true) {
+            if (this.queue.length > 0) {
+                yield this.queue.shift();
+            }
+            else if (this.done) {
+                return;
+            }
+            else {
+                const result = await new Promise((resolve) => this.waiting.push(resolve));
+                if (result.done)
+                    return;
+                yield result.value;
+            }
+        }
+    }
+    result() {
+        return this.finalResultPromise;
+    }
+}
+class AssistantMessageEventStream extends EventStream {
+    constructor() {
+        super((event) => event.type === "done" || event.type === "error", (event) => {
+            if (event.type === "done") {
+                return event.message;
+            }
+            else if (event.type === "error") {
+                return event.error;
+            }
+            throw new Error("Unexpected event type for final result");
+        });
+    }
+}
+/** Factory function for AssistantMessageEventStream (for use in extensions) */
+function createAssistantMessageEventStream() {
+    return new AssistantMessageEventStream();
+}
+//# sourceMappingURL=event-stream.js.map
+
+function createSetupErrorMessage(model, error) {
+    return {
+        role: "assistant",
+        content: [],
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+        },
+        stopReason: "error",
+        errorMessage: error instanceof Error ? error.message : String(error),
+        timestamp: Date.now(),
+    };
+}
+function hasResult(source) {
+    return typeof source.result === "function";
+}
+async function forwardStream(target, source) {
+    for await (const event of source) {
+        target.push(event);
+    }
+    target.end(hasResult(source) ? await source.result() : undefined);
+}
+/**
+ * Returns a stream synchronously while running async setup (auth resolution,
+ * lazy module loading) behind it. Setup failures terminate the stream with an
+ * error event.
+ */
+function lazyStream(model, setup) {
+    const outer = new AssistantMessageEventStream();
+    setup()
+        .then((inner) => forwardStream(outer, inner))
+        .catch((error) => {
+        const message = createSetupErrorMessage(model, error);
+        outer.push({ type: "error", reason: "error", error: message });
+        outer.end(message);
+    });
+    return outer;
+}
+function lazyApi(load, capabilities) {
+    const api = {
+        stream: (model, context, options) => lazyStream(model, async () => (await load()).stream(model, context, options)),
+        streamSimple: (model, context, options) => lazyStream(model, async () => (await load()).streamSimple(model, context, options)),
+    };
+    if (capabilities?.fetchDeferred) {
+        api.fetchDeferred = (model, handle, options) => lazyStream(model, async () => {
+            const implementation = await load();
+            if (!implementation.fetchDeferred)
+                throw new Error("API does not support deferred responses");
+            return implementation.fetchDeferred(model, handle, options);
+        });
+    }
+    if (capabilities?.cancelDeferred) {
+        api.cancelDeferred = async (model, handle, options) => {
+            const implementation = await load();
+            if (!implementation.cancelDeferred)
+                throw new Error("API cannot cancel deferred responses");
+            await implementation.cancelDeferred(model, handle, options);
+        };
+    }
+    return api;
+}
+//# sourceMappingURL=lazy.js.map
+
+const AGENT_ERROR_CODES = [
+    "AGENT_RUN_ACTIVE",
+    "AGENT_INTERRUPT_PENDING",
+    "AGENT_RUN_LIMIT_REACHED",
+    "AGENT_TOOL_RUNTIME_UNAVAILABLE",
+    "BROWSER_SKILL_REQUIRED",
+    "CONTEXT_SNAPSHOT_TOO_LARGE",
+    "INVALID_MODEL_RESPONSE",
+    "INVALID_RUN_INPUT",
+    "INVALID_SKILL_CONFIG",
+    "INVALID_TOOL_BATCH",
+    "UNKNOWN_MODEL_TOOL"
+];
+const AGENT_MODEL_ERROR_CODES = [
+    "AGENT_MODEL_SWITCH_BLOCKED",
+    "AGENT_RUN_BLOCKED",
+    "INVALID_MODEL_RESPONSE",
+    "MODEL_CONFIG_INVALID",
+    "MODEL_NOT_FOUND",
+    "MODEL_REQUEST_FAILED",
+    "MODEL_INPUT_UNSUPPORTED"
+];
+const AGENT_ERROR_CODE_SET = new Set(AGENT_ERROR_CODES);
+const AGENT_MODEL_ERROR_CODE_SET = new Set(AGENT_MODEL_ERROR_CODES);
+function isAgentError(error) {
+    if (!error || typeof error !== "object") return false;
+    const candidate = error;
+    if (candidate.type !== "agent_error" || typeof candidate.code !== "string" || typeof candidate.message !== "string") {
+        return false;
+    }
+    if (candidate.domain === "agent") {
+        return AGENT_ERROR_CODE_SET.has(candidate.code);
+    }
+    if (candidate.domain === "model") {
+        return AGENT_MODEL_ERROR_CODE_SET.has(candidate.code);
+    }
+    return false;
+}
+class AgentError extends Error {
+    code;
+    details;
+    domain;
+    type = "agent_error";
+    constructor(code, message, details, domain = "agent"){
+        super(message), this.code = code, this.details = details, this.domain = domain;
+        this.name = "AgentError";
+    }
+}
+
+
+class AgentModelError extends AgentError {
+    code;
+    constructor(code, message){
+        super(code, message, undefined, "model"), this.code = code;
+        this.name = "AgentModelError";
+    }
+}
+
+
+function parseArguments(value) {
+    try {
+        const parsed = JSON.parse(value);
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
+    } catch  {
+        return {};
+    }
+}
+function genericAssistant(message, model) {
+    return {
+        role: "assistant",
+        api: model.api,
+        provider: model.provider,
+        model: model.id,
+        content: [
+            ...message.content ? [
+                {
+                    type: "text",
+                    text: message.content
+                }
+            ] : [],
+            ...message.toolCalls.map((call)=>({
+                    type: "toolCall",
+                    id: call.id,
+                    name: call.name,
+                    arguments: parseArguments(call.arguments)
+                }))
+        ],
+        usage: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0,
+            totalTokens: 0,
+            cost: {
+                input: 0,
+                output: 0,
+                cacheRead: 0,
+                cacheWrite: 0,
+                total: 0
+            }
+        },
+        stopReason: message.toolCalls.length ? "toolUse" : "stop",
+        timestamp: Date.now()
+    };
+}
+function toolIsError(content) {
+    try {
+        const parsed = JSON.parse(content);
+        return "error" in parsed;
+    } catch  {
+        return false;
+    }
+}
+function createPiContext(messages, tools, model, replay) {
+    // pi-ai exposes one trusted systemPrompt rather than chronological system messages.
+    // Keep canonical checkpoints append-only, then consolidate them in their original order.
+    const system = [];
+    const piMessages = [];
+    messages.forEach((message, index)=>{
+        if (message.role === "system" || message.role === "application_context") {
+            system.push(message.content);
+            return;
+        }
+        if (message.role === "user") {
+            const content = typeof message.content === "string" ? message.content : message.content.map((part)=>{
+                if (part.type === "text") return part;
+                if (!model.input.includes("image")) throw new AgentModelError("MODEL_INPUT_UNSUPPORTED", "The configured model does not support image input.");
+                if (part.source.type !== "data") throw new AgentModelError("MODEL_INPUT_UNSUPPORTED", "Only inline image data is supported.");
+                return {
+                    type: "image",
+                    data: part.source.value,
+                    mimeType: part.source.mimeType
+                };
+            });
+            piMessages.push({
+                role: "user",
+                content,
+                timestamp: Date.now()
+            });
+            return;
+        }
+        if (message.role === "assistant") {
+            piMessages.push(replay.get(index) ?? genericAssistant(message, model));
+            return;
+        }
+        if (message.role === "tool") {
+            piMessages.push({
+                role: "toolResult",
+                toolCallId: message.toolCallId,
+                toolName: message.name,
+                content: [
+                    {
+                        type: "text",
+                        text: message.content
+                    }
+                ],
+                isError: toolIsError(message.content),
+                timestamp: Date.now()
+            });
+        }
+    });
+    const piTools = tools.map((tool)=>({
+            name: tool.name,
+            description: tool.description,
+            parameters: tool.inputSchema
+        }));
+    return {
+        ...system.length ? {
+            systemPrompt: system.join("\n\n")
+        } : {},
+        messages: piMessages,
+        tools: piTools
+    };
+}
+function fromPiAssistant(message) {
+    const text = message.content.filter((block)=>block.type === "text").map((block)=>block.text).join("");
+    return {
+        content: text || null,
+        toolCalls: message.content.filter((block)=>block.type === "toolCall").map((block)=>({
+                id: block.id,
+                name: block.name,
+                arguments: JSON.stringify(block.arguments)
+            })),
+        usage: {
+            promptTokens: message.usage.input,
+            cachedPromptTokens: message.usage.cacheRead,
+            cacheMissPromptTokens: Math.max(0, message.usage.input - message.usage.cacheRead),
+            completionTokens: message.usage.output,
+            totalTokens: message.usage.totalTokens
+        }
+    };
+}
+
+
+
+
+const DEFAULT_CAPABILITIES = {
+    reasoning: false,
+    input: [
+        "text"
+    ],
+    contextWindow: 128000,
+    maxOutputTokens: 16384
+};
+const KEYLESS_GATEWAY_API_KEY = "nexface-keyless-gateway";
+function invalid(message) {
+    throw new AgentModelError("MODEL_CONFIG_INVALID", message);
+}
+function assertNonEmpty(value, name) {
+    if (typeof value !== "string" || !value.trim()) invalid(`${name} must be a non-empty string.`);
+}
+function normalizedBaseURL(value, fallback) {
+    const candidate = value ?? fallback;
+    assertNonEmpty(candidate, "baseURL");
+    const browserOrigin = globalThis.location?.origin;
+    let url;
+    try {
+        url = browserOrigin ? new URL(candidate, browserOrigin) : new URL(candidate);
+    } catch  {
+        return invalid("baseURL must be absolute outside a browser environment.");
+    }
+    if (url.search || url.hash) invalid("baseURL must not contain a query or hash.");
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        invalid("baseURL must use http or https.");
+    }
+    if (url.username || url.password) invalid("baseURL must not contain credentials.");
+    url.pathname = url.pathname.replace(/\/+$/, "") || "/";
+    return url.toString().replace(/\/$/, "");
+}
+function hasAuthenticationHeader(headers) {
+    const authenticationHeaders = new Set([
+        "authorization",
+        "x-api-key",
+        "x-goog-api-key"
+    ]);
+    for (const [name, value] of Object.entries(headers ?? {})){
+        if (!authenticationHeaders.has(name.toLowerCase())) continue;
+        assertNonEmpty(value, `headers.${name}`);
+        return true;
+    }
+    return false;
+}
+function assertFiniteNumber(value, name, minimum) {
+    if (value !== undefined && (!Number.isFinite(value) || value < minimum)) {
+        invalid(`${name} must be a finite number greater than or equal to ${minimum}.`);
+    }
+}
+function stripKeylessSecret(input, init) {
+    const headers = new Headers(init?.headers);
+    for (const name of [
+        "authorization",
+        "x-api-key",
+        "x-goog-api-key"
+    ]){
+        const value = headers.get(name);
+        if (value === KEYLESS_GATEWAY_API_KEY || value === `Bearer ${KEYLESS_GATEWAY_API_KEY}`) {
+            headers.delete(name);
+        }
+    }
+    let nextInput = input;
+    const rawURL = input instanceof Request ? input.url : String(input);
+    try {
+        const url = new URL(rawURL, globalThis.location?.origin);
+        for (const name of [
+            "key",
+            "api_key"
+        ]){
+            if (url.searchParams.get(name) === KEYLESS_GATEWAY_API_KEY) url.searchParams.delete(name);
+        }
+        nextInput = input instanceof Request ? new Request(url, input) : url;
+    } catch  {
+    // Keep non-URL RequestInfo unchanged.
+    }
+    return [
+        nextInput,
+        {
+            ...init,
+            headers
+        }
+    ];
+}
+function createKeylessFetch(fetchImpl) {
+    return async (input, init)=>{
+        const [nextInput, nextInit] = stripKeylessSecret(input, init);
+        return fetchImpl(nextInput, nextInit);
+    };
+}
+async function consumeStream(stream, onTextDelta) {
+    let result;
+    for await (const event of stream){
+        if (event.type === "text_delta") onTextDelta?.(event.delta);
+        if (event.type === "done") result = event.message;
+        if (event.type === "error") {
+            if (event.reason === "aborted") {
+                throw new DOMException("The model request was aborted.", "AbortError");
+            }
+            throw new AgentModelError("MODEL_REQUEST_FAILED", "The model request failed.");
+        }
+    }
+    if (!result) {
+        throw new AgentModelError("INVALID_MODEL_RESPONSE", "Model stream ended without a final message.");
+    }
+    return result;
+}
+class PiModelBinding {
+    info;
+    #replay = new Map();
+    #model;
+    #stream;
+    #options;
+    constructor(info, model, stream, options){
+        this.info = info;
+        this.#model = model;
+        this.#stream = stream;
+        this.#options = options;
+    }
+    async complete(request) {
+        const raw = await consumeStream(this.#stream.streamSimple(this.#model, createPiContext(request.messages, request.tools, this.#model, this.#replay), {
+            ...this.#options,
+            signal: request.signal,
+            sessionId: request.agentId
+        }), request.onTextDelta);
+        const response = fromPiAssistant(raw);
+        const replayIndex = request.messages.length;
+        let accepted = false;
+        return {
+            ...response,
+            accept: ()=>{
+                if (accepted) return;
+                accepted = true;
+                this.#replay.set(replayIndex, raw);
+            }
+        };
+    }
+}
+function resolveModel(definition, config, baseURL) {
+    const catalogModel = definition.resolveCatalogModel?.(config.model);
+    if (definition.resolveCatalogModel && !catalogModel) {
+        throw new AgentModelError("MODEL_NOT_FOUND", `Model "${config.model}" was not found for provider "${definition.provider}".`);
+    }
+    const capabilities = {
+        ...DEFAULT_CAPABILITIES,
+        ...config.capabilities
+    };
+    if (catalogModel) {
+        return {
+            ...catalogModel,
+            baseUrl: baseURL,
+            ...config.capabilities?.reasoning === undefined ? {} : {
+                reasoning: config.capabilities.reasoning
+            },
+            ...config.capabilities?.input === undefined ? {} : {
+                input: [
+                    ...config.capabilities.input
+                ]
+            },
+            ...config.capabilities?.contextWindow === undefined ? {} : {
+                contextWindow: config.capabilities.contextWindow
+            },
+            ...config.capabilities?.maxOutputTokens === undefined ? {} : {
+                maxTokens: config.capabilities.maxOutputTokens
+            }
+        };
+    }
+    return {
+        id: config.model,
+        name: config.model,
+        api: definition.api,
+        provider: definition.provider,
+        baseUrl: baseURL,
+        reasoning: capabilities.reasoning,
+        input: capabilities.input,
+        cost: {
+            input: 0,
+            output: 0,
+            cacheRead: 0,
+            cacheWrite: 0
+        },
+        contextWindow: capabilities.contextWindow,
+        maxTokens: capabilities.maxOutputTokens
+    };
+}
+function createProtocolModelConfig(definition, config) {
+    if (!config || typeof config !== "object") invalid("model config must be an object.");
+    assertNonEmpty(config.model, "model");
+    if (config.apiKey !== undefined) assertNonEmpty(config.apiKey, "apiKey");
+    if (config.apiKey && hasAuthenticationHeader(config.headers)) {
+        invalid("apiKey and an authentication header cannot be configured together.");
+    }
+    if (definition.supportsCustomFetch === false && config.fetch) {
+        invalid(`Custom fetch is not supported for provider "${definition.provider}".`);
+    }
+    if (definition.resolveCatalogModel && config.capabilities !== undefined) {
+        invalid(`Capability overrides are not supported for provider "${definition.provider}".`);
+    }
+    assertFiniteNumber(config.temperature, "temperature", 0);
+    assertFiniteNumber(config.maxTokens, "maxTokens", 1);
+    assertFiniteNumber(config.timeoutMs, "timeoutMs", 1);
+    assertFiniteNumber(config.maxRetries, "maxRetries", 0);
+    if (config.maxRetries !== undefined && !Number.isInteger(config.maxRetries)) {
+        invalid("maxRetries must be an integer.");
+    }
+    assertFiniteNumber(config.capabilities?.contextWindow, "capabilities.contextWindow", 1);
+    assertFiniteNumber(config.capabilities?.maxOutputTokens, "capabilities.maxOutputTokens", 1);
+    const baseURL = normalizedBaseURL(config.baseURL, definition.defaultBaseURL);
+    const browserOrigin = globalThis.location?.origin;
+    if (browserOrigin && config.apiKey === undefined && !hasAuthenticationHeader(config.headers) && new URL(baseURL).origin !== browserOrigin) {
+        invalid("Keyless browser model requests must use a same-origin gateway.");
+    }
+    if ((definition.api === "openai-completions" || definition.api === "openai-responses") && /\/(?:chat\/completions|responses)$/i.test(new URL(baseURL).pathname)) {
+        invalid("baseURL must be an API root and must not include the final endpoint.");
+    }
+    const preparedConfig = {
+        ...config,
+        baseURL,
+        ...config.headers === undefined ? {} : {
+            headers: {
+                ...config.headers
+            }
+        },
+        ...config.capabilities === undefined ? {} : {
+            capabilities: {
+                ...config.capabilities,
+                ...config.capabilities.input === undefined ? {} : {
+                    input: [
+                        ...config.capabilities.input
+                    ]
+                }
+            }
+        }
+    };
+    const info = {
+        provider: definition.provider,
+        model: preparedConfig.model
+    };
+    return defineAgentModelConfig({
+        info,
+        async resolve () {
+            const configuredFetch = preparedConfig.fetch ?? globalThis.fetch;
+            const options = {
+                ...preparedConfig.temperature === undefined ? {} : {
+                    temperature: preparedConfig.temperature
+                },
+                ...preparedConfig.maxTokens === undefined ? {} : {
+                    maxTokens: preparedConfig.maxTokens
+                },
+                ...preparedConfig.reasoning === undefined ? {} : {
+                    reasoning: preparedConfig.reasoning
+                },
+                ...preparedConfig.timeoutMs === undefined ? {} : {
+                    timeoutMs: preparedConfig.timeoutMs
+                },
+                ...preparedConfig.maxRetries === undefined ? {} : {
+                    maxRetries: preparedConfig.maxRetries
+                },
+                ...preparedConfig.headers === undefined ? {} : {
+                    headers: preparedConfig.headers
+                },
+                ...definition.supportsCustomFetch === false || preparedConfig.apiKey === undefined ? {} : {
+                    fetch: configuredFetch
+                },
+                ...preparedConfig.apiKey === undefined ? {
+                    apiKey: KEYLESS_GATEWAY_API_KEY,
+                    ...definition.supportsCustomFetch === false ? {} : {
+                        fetch: createKeylessFetch(configuredFetch)
+                    }
+                } : {
+                    apiKey: preparedConfig.apiKey
+                }
+            };
+            return new PiModelBinding(info, resolveModel(definition, preparedConfig, baseURL), definition.stream, options);
+        }
+    });
+}
+
+export { AgentModelError, AssistantMessageEventStream, createProtocolModelConfig, lazyApi };

package/dist/models/956.js

@@ -0,0 +1,5 @@
+function flattenModelCatalog(_provider, groups) {
+    return Object.assign({}, ...Object.values(groups));
+}
+//# sourceMappingURL=model-catalog.js.map
+export { flattenModelCatalog };