@uncensoredcode/openbridge 0.1.0

package/packages/runtime/dist/tools/workspace-path.js

@@ -0,0 +1,70 @@
+import { mkdir, realpath } from "node:fs/promises";
+import path from "node:path";
+import { executionTypesModule } from "../execution/types.js";
+const { ToolExecutionError } = executionTypesModule;
+async function ensureWorkspaceRoot(workspaceRoot) {
+    await mkdir(workspaceRoot, { recursive: true });
+    return realpath(workspaceRoot);
+}
+async function resolveWorkspacePath(input) {
+    const requestPath = input.requestedPath.trim();
+    if (!requestPath) {
+        throw new ToolExecutionError("invalid_arguments", "path must be a non-empty string.");
+    }
+    const canonicalRoot = await ensureWorkspaceRoot(input.workspaceRoot);
+    const lexicalTarget = path.isAbsolute(requestPath)
+        ? path.resolve(requestPath)
+        : path.resolve(canonicalRoot, requestPath);
+    assertWithinWorkspace(canonicalRoot, lexicalTarget);
+    const canonicalTarget = input.kind === "read"
+        ? await realpath(lexicalTarget).catch((error) => {
+            if (error.code === "ENOENT") {
+                throw new ToolExecutionError("not_found", `File does not exist: ${requestPath}`);
+            }
+            throw error;
+        })
+        : await resolveWriteTarget(canonicalRoot, lexicalTarget);
+    assertWithinWorkspace(canonicalRoot, canonicalTarget);
+    return {
+        absolutePath: canonicalTarget,
+        relativePath: toWorkspaceRelativePath(canonicalRoot, canonicalTarget),
+        workspaceRoot: canonicalRoot
+    };
+}
+function assertWithinWorkspace(workspaceRoot, targetPath) {
+    const relative = path.relative(workspaceRoot, targetPath);
+    if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+        return;
+    }
+    throw new ToolExecutionError("workspace_violation", `Path "${targetPath}" resolves outside the configured workspace root.`);
+}
+async function resolveWriteTarget(workspaceRoot, lexicalTarget) {
+    const nearestExistingAncestor = await findNearestExistingAncestor(workspaceRoot, lexicalTarget);
+    const canonicalAncestor = await realpath(nearestExistingAncestor);
+    const suffix = path.relative(nearestExistingAncestor, lexicalTarget);
+    return suffix ? path.resolve(canonicalAncestor, suffix) : canonicalAncestor;
+}
+async function findNearestExistingAncestor(workspaceRoot, lexicalTarget) {
+    let cursor = lexicalTarget;
+    while (true) {
+        try {
+            await realpath(cursor);
+            return cursor;
+        }
+        catch (error) {
+            const next = path.dirname(cursor);
+            if (next === cursor || next.length < workspaceRoot.length) {
+                throw error;
+            }
+            cursor = next;
+        }
+    }
+}
+function toWorkspaceRelativePath(workspaceRoot, absolutePath) {
+    const relative = path.relative(workspaceRoot, absolutePath);
+    return relative || ".";
+}
+export const workspacePathModule = {
+    ensureWorkspaceRoot,
+    resolveWorkspacePath
+};

package/packages/runtime/dist/tools/write.d.ts

@@ -0,0 +1,9 @@
+import type { RuntimeTool } from "../execution/types.ts";
+type WriteToolOptions = {
+    runtimeRoot: string;
+};
+declare function createWriteTool(options: WriteToolOptions): RuntimeTool;
+export declare const writeModule: {
+    createWriteTool: typeof createWriteTool;
+};
+export {};

package/packages/runtime/dist/tools/write.js

@@ -0,0 +1,59 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { executionTypesModule } from "../execution/types.js";
+import { runtimePathModule } from "./runtime-path.js";
+import { textFileModule } from "./text-file.js";
+const { ToolExecutionError } = executionTypesModule;
+const { assertTextContent, MAX_FILE_WRITE_BYTES, writeTextFileAtomic } = textFileModule;
+const { resolveRuntimePath } = runtimePathModule;
+function createWriteTool(options) {
+    return {
+        definition: {
+            name: "write",
+            description: "Create or overwrite a UTF-8 text file on the local filesystem.",
+            inputSchema: {
+                type: "object",
+                properties: {
+                    path: {
+                        type: "string",
+                        description: "Absolute path or path relative to the runtime root."
+                    },
+                    content: {
+                        type: "string",
+                        description: "Full file contents to write."
+                    }
+                },
+                required: ["path", "content"]
+            }
+        },
+        async execute(args) {
+            const resolvedPath = await resolveRuntimePath(options.runtimeRoot, requireString(args, "path"));
+            const content = requireString(args, "content");
+            const bytesWritten = assertTextContent(content, resolvedPath, MAX_FILE_WRITE_BYTES);
+            try {
+                await mkdir(path.dirname(resolvedPath), { recursive: true });
+                await writeTextFileAtomic(resolvedPath, content);
+                return {
+                    path: resolvedPath,
+                    bytesWritten
+                };
+            }
+            catch (error) {
+                if (error instanceof ToolExecutionError) {
+                    throw error;
+                }
+                throw new ToolExecutionError("io_error", `Unable to write file "${resolvedPath}": ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+    };
+}
+function requireString(args, key) {
+    const value = args[key];
+    if (typeof value === "string") {
+        return value;
+    }
+    throw new ToolExecutionError("invalid_arguments", `${key} must be a string.`);
+}
+export const writeModule = {
+    createWriteTool
+};

package/packages/server/dist/bridge/bridge-model-catalog.d.ts

@@ -0,0 +1,56 @@
+import { z } from "zod";
+import type { ProviderRecord } from "./stores/provider-store.ts";
+declare const bridgeModelSchema: z.ZodObject<{
+    id: z.ZodString;
+    object: z.ZodLiteral<"model">;
+    created: z.ZodNumber;
+    owned_by: z.ZodString;
+}, z.core.$strip>;
+type BridgeModelRecord = z.infer<typeof bridgeModelSchema>;
+type ResolvedBridgeModel = {
+    provider: ProviderRecord;
+    modelId: string;
+    publicModelId: string;
+    available: boolean;
+};
+declare function buildModelListResponse(providers: ProviderRecord[]): {
+    object: "list";
+    data: {
+        id: string;
+        object: "model";
+        created: number;
+        owned_by: string;
+    }[];
+};
+declare function defaultModelForProvider(provider: ProviderRecord | null): string;
+declare function resolveBridgeModel(providers: ProviderRecord[], publicModelId: string): ResolvedBridgeModel | null;
+export declare const bridgeModelCatalogModule: {
+    bridgeModelSchema: z.ZodObject<{
+        id: z.ZodString;
+        object: z.ZodLiteral<"model">;
+        created: z.ZodNumber;
+        owned_by: z.ZodString;
+    }, z.core.$strip>;
+    bridgeModelListResponseSchema: z.ZodObject<{
+        object: z.ZodLiteral<"list">;
+        data: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            object: z.ZodLiteral<"model">;
+            created: z.ZodNumber;
+            owned_by: z.ZodString;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    createModelRequestSchema: z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodString;
+    }, z.core.$strict>;
+    modelMutationResponseSchema: z.ZodObject<{
+        ok: z.ZodLiteral<true>;
+        providerId: z.ZodString;
+        modelId: z.ZodString;
+    }, z.core.$strict>;
+    buildModelListResponse: typeof buildModelListResponse;
+    defaultModelForProvider: typeof defaultModelForProvider;
+    resolveBridgeModel: typeof resolveBridgeModel;
+};
+export type { BridgeModelRecord, ResolvedBridgeModel };

package/packages/server/dist/bridge/bridge-model-catalog.js

@@ -0,0 +1,100 @@
+import { z } from "zod";
+import { providerTransportProfileModule } from "./providers/provider-transport-profile.js";
+const { defaultModelForProviderRecord, readConfiguredModelIds } = providerTransportProfileModule;
+const nonEmptyString = (field) => z.string().trim().min(1, `${field} is required.`);
+const bridgeModelSchema = z.object({
+    id: nonEmptyString("id"),
+    object: z.literal("model"),
+    created: z.number().int().nonnegative(),
+    owned_by: nonEmptyString("owned_by")
+});
+const bridgeModelListResponseSchema = z.object({
+    object: z.literal("list"),
+    data: z.array(bridgeModelSchema)
+});
+const createModelRequestSchema = z
+    .object({
+    provider: nonEmptyString("provider"),
+    model: nonEmptyString("model")
+})
+    .strict();
+const modelMutationResponseSchema = z
+    .object({
+    ok: z.literal(true),
+    providerId: nonEmptyString("providerId"),
+    modelId: nonEmptyString("modelId")
+})
+    .strict();
+function buildModelListResponse(providers) {
+    const data = providers
+        .flatMap((provider) => listModelsForProvider(provider))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return bridgeModelListResponseSchema.parse({
+        object: "list",
+        data
+    });
+}
+function defaultModelForProvider(provider) {
+    return defaultModelForProviderRecord(provider);
+}
+function resolveBridgeModel(providers, publicModelId) {
+    for (const provider of providers) {
+        for (const modelId of resolveModelIdsForProvider(provider)) {
+            if (`${provider.id}/${modelId}` !== publicModelId) {
+                continue;
+            }
+            return {
+                provider,
+                modelId,
+                publicModelId,
+                available: provider.enabled
+            };
+        }
+        const dynamicModelId = readDynamicModelId(provider, publicModelId);
+        if (dynamicModelId) {
+            return {
+                provider,
+                modelId: dynamicModelId,
+                publicModelId,
+                available: provider.enabled
+            };
+        }
+    }
+    return null;
+}
+function listModelsForProvider(provider) {
+    if (!provider.enabled) {
+        return [];
+    }
+    const modelIds = resolveModelIdsForProvider(provider);
+    const created = toUnixTimestamp(provider.createdAt);
+    return modelIds.map((modelId) => bridgeModelSchema.parse({
+        id: `${provider.id}/${modelId}`,
+        object: "model",
+        created,
+        owned_by: provider.id
+    }));
+}
+function resolveModelIdsForProvider(provider) {
+    return readConfiguredModelIds(provider.config);
+}
+function readDynamicModelId(provider, publicModelId) {
+    const prefix = `${provider.id}/`;
+    if (!publicModelId.startsWith(prefix)) {
+        return null;
+    }
+    const modelId = publicModelId.slice(prefix.length).trim();
+    return modelId ? modelId : null;
+}
+function toUnixTimestamp(value) {
+    return Math.floor(Date.parse(value) / 1000);
+}
+export const bridgeModelCatalogModule = {
+    bridgeModelSchema,
+    bridgeModelListResponseSchema,
+    createModelRequestSchema,
+    modelMutationResponseSchema,
+    buildModelListResponse,
+    defaultModelForProvider,
+    resolveBridgeModel
+};

package/packages/server/dist/bridge/bridge-runtime-service.d.ts

@@ -0,0 +1,61 @@
+import type { AssistantResponse, BridgeSessionTurn, CompiledProviderMessage, ProviderTransport, SessionBindingStore } from "@uncensoredcode/openbridge/runtime";
+import type { BridgeServerConfig } from "../config/index.ts";
+import type { BridgeApiToolProfile, BridgeChatCompletionRequest, BridgeChatCompletionTool, BridgeMessageRequest, BridgeMessageResponse } from "../shared/api-schema.ts";
+import type { ProviderStreamFragment } from "./providers/provider-streams.ts";
+import type { ProviderRecord } from "./stores/provider-store.ts";
+import type { SessionPackageStore } from "./stores/session-package-store.ts";
+type BridgeRuntimeServiceDependencies = {
+    config: BridgeServerConfig;
+    loadProvider?: (providerId: string) => ProviderRecord | null;
+    sessionBindingStore?: SessionBindingStore;
+    sessionPackageStore?: SessionPackageStore;
+    transport?: ProviderTransport;
+    onLog?: (event: BridgeRuntimeServiceLogEvent) => void;
+};
+type BridgeRuntimeService = ReturnType<typeof createBridgeRuntimeService>;
+type BridgeRuntimeServiceLogEvent = {
+    scope: "request" | "provider" | "runtime";
+    event: string;
+    requestId: string;
+    detail: Record<string, unknown>;
+};
+type BridgeRuntimeExecutionRequest = {
+    sessionId: string;
+    input: string;
+    providerId: string;
+    modelId: string;
+    metadata?: Record<string, unknown>;
+    toolProfile?: BridgeApiToolProfile;
+    sessionHistory?: BridgeSessionTurn[];
+    persistSession?: boolean;
+};
+type ChatCompletionPacketRequest = {
+    sessionId: string;
+    providerId: string;
+    modelId: string;
+    messages: CompiledProviderMessage[];
+    tools: BridgeChatCompletionTool[];
+    toolChoice?: BridgeChatCompletionRequest["tool_choice"];
+    continuation: boolean;
+    toolFollowUp: boolean;
+    metadata?: Record<string, unknown>;
+    persistSession?: boolean;
+};
+declare function createBridgeRuntimeService(dependencies: BridgeRuntimeServiceDependencies): {
+    respond(request: BridgeMessageRequest, pathSessionId?: string): Promise<BridgeMessageResponse>;
+    execute(request: BridgeRuntimeExecutionRequest): Promise<BridgeMessageResponse>;
+    completeChatCompletionPacket(request: ChatCompletionPacketRequest): Promise<{
+        packet: AssistantResponse;
+        providerBindingReused: boolean;
+    }>;
+    streamChatCompletionPacket(request: ChatCompletionPacketRequest): Promise<{
+        content: AsyncIterable<ProviderStreamFragment>;
+        packet: Promise<AssistantResponse>;
+        providerBindingReused: boolean;
+    }>;
+    streamChatCompletion(request: BridgeRuntimeExecutionRequest): Promise<AsyncIterable<string>>;
+};
+export declare const bridgeRuntimeServiceModule: {
+    createBridgeRuntimeService: typeof createBridgeRuntimeService;
+};
+export type { BridgeRuntimeService, BridgeRuntimeServiceDependencies, BridgeRuntimeServiceLogEvent };