veryfront 0.1.321 → 0.1.323

package/src/src/embedding/veryfront-cloud/provider.ts

@@ -7,6 +7,7 @@ import {
   parseVeryfrontCloudModelId,
   requireVeryfrontCloudBootstrap,
 } from "../../provider/veryfront-cloud/shared.js";
+import { createVeryfrontCloudOpenAIEmbeddingModel } from "../../provider/veryfront-cloud/openai.js";
 
 export function createVeryfrontCloudEmbeddingModel(modelId: string): EmbeddingRuntime {
   const { provider, modelId: upstreamModelId } = parseVeryfrontCloudModelId(modelId, "embedding");
@@ -16,9 +17,11 @@ export function createVeryfrontCloudEmbeddingModel(modelId: string): EmbeddingRu
 
   switch (provider) {
     case "openai":
-      throw new Error(
-        "OpenAI provider not installed. Add @veryfront/ext-openai to use openai embedding models via veryfront-cloud.",
-      );
+      return createVeryfrontCloudOpenAIEmbeddingModel(upstreamModelId, {
+        apiToken,
+        baseURL,
+        fetch,
+      });
 
     case "google":
       return createGoogleEmbeddingRuntime({

package/src/src/provider/shared/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Shared plumbing consumed by the `@veryfront/ext-*` provider extensions.
+ *
+ * This barrel is the stable public surface: implementations currently live
+ * in `runtime-loader.ts` and `runtime-loader/` subdirectory. Future PRs
+ * (post ext-anthropic / ext-google extraction) may move the implementations
+ * into this directory; extensions keep importing from here unchanged.
+ *
+ * @module provider/shared
+ */
+
+// URL builders
+export {
+  getAnthropicMessagesUrl,
+  getGoogleEmbeddingUrl,
+  getGoogleGenerateContentUrl,
+  getGoogleStreamGenerateContentUrl,
+  getOpenAIChatCompletionsUrl,
+  getOpenAIEmbeddingUrl,
+  getOpenAIResponsesUrl,
+} from "../runtime-loader/provider-endpoints.js";
+
+// Request init builders
+export {
+  createAnthropicRequestInit,
+  createGoogleRequestInit,
+  createOpenAIRequestInit,
+} from "../runtime-loader/provider-request-init.js";
+
+// Tool-input status transitions
+export {
+  TOOL_INPUT_PENDING_THRESHOLD_MS,
+  withToolInputStatusTransitions,
+} from "../runtime-loader/tool-input-status.js";
+
+// Retry / error / HTTP plumbing (currently in runtime-loader.ts).
+export {
+  buildProviderError,
+  createWarningCollector,
+  isNumberArray,
+  mergeUsage,
+  parseRetryAfterMs,
+  ProviderError,
+  ProviderOverloadedError,
+  ProviderQuotaError,
+  ProviderRateLimitError,
+  ProviderRequestError,
+  readProviderOptions,
+  readRecord,
+  readTextParts,
+  requestJson,
+  requestStream,
+  stringifyJsonValue,
+  toOpenAICompatibleMessages,
+  toOpenAICompatibleTools,
+} from "../runtime-loader.js";
+
+export type {
+  OpenAICompatibleChatMessage,
+  OpenAICompatibleChatRequest,
+  RuntimePromptMessage,
+} from "../runtime-loader.js";

package/src/src/provider/veryfront-cloud/openai.ts

@@ -0,0 +1,34 @@
+import type { EmbeddingRuntime, ModelRuntime } from "../types.js";
+import { OpenAIProvider } from "../../../extensions/ext-openai/src/openai-provider.js";
+
+const openAIProvider = new OpenAIProvider();
+
+interface VeryfrontCloudOpenAIConfig {
+  apiToken: string;
+  baseURL: string;
+  fetch: typeof globalThis.fetch;
+}
+
+export function createVeryfrontCloudOpenAIModel(
+  modelId: string,
+  config: VeryfrontCloudOpenAIConfig,
+): ModelRuntime {
+  return openAIProvider.createModel(modelId, {
+    credential: config.apiToken,
+    baseURL: config.baseURL,
+    name: "veryfront-cloud",
+    fetch: config.fetch,
+  });
+}
+
+export function createVeryfrontCloudOpenAIEmbeddingModel(
+  modelId: string,
+  config: VeryfrontCloudOpenAIConfig,
+): EmbeddingRuntime {
+  return openAIProvider.createEmbedding(modelId, {
+    credential: config.apiToken,
+    baseURL: config.baseURL,
+    name: "veryfront-cloud",
+    fetch: config.fetch,
+  });
+}

package/src/src/provider/veryfront-cloud/provider.ts

@@ -10,6 +10,7 @@ import {
   parseVeryfrontCloudModelId,
   requireVeryfrontCloudBootstrap,
 } from "./shared.js";
+import { createVeryfrontCloudOpenAIModel } from "./openai.js";
 
 export function createVeryfrontCloudModel(modelId: string): ModelRuntime {
   const { provider, modelId: upstreamModelId } = parseVeryfrontCloudModelId(modelId, "language");
@@ -61,9 +62,11 @@ export function createVeryfrontCloudModel(modelId: string): ModelRuntime {
           fetch,
         });
       }
-      throw new Error(
-        "OpenAI provider not installed. Add @veryfront/ext-openai to use openai/moonshotai models via veryfront-cloud.",
-      );
+      return createVeryfrontCloudOpenAIModel(upstreamModelId, {
+        apiToken,
+        baseURL,
+        fetch,
+      });
     }
 
     default: {

package/src/src/proxy/main.ts

@@ -25,6 +25,8 @@ import * as dntShim from "../../_dnt.shims.js";
 import { createProxyHandler, INTERNAL_PROXY_HEADERS, type ProxyConfig } from "./handler.js";
 import { createCacheFromEnv } from "./cache/index.js";
 import { isRetryableConnectionError } from "./retry.js";
+import { register } from "../extensions/contracts.js";
+import { createAuthProvider } from "../../extensions/ext-jwt/src/index.js";
 import {
   endSpan,
   extractContext,
@@ -112,6 +114,8 @@ const VERYFRONT_SERVER_RETRY_DELAY_MS = parseInt(
   getEnv("VERYFRONT_SERVER_RETRY_DELAY_MS") || String(DEFAULT_SERVER_RETRY_DELAY_MS),
 );
 
+register("AuthProvider", createAuthProvider({}));
+
 // Initialize cache and proxy handler
 const cache = await createCacheFromEnv();
 const proxyHandler = createProxyHandler({

package/src/src/tool/host-tools.ts

@@ -0,0 +1,92 @@
+import * as dntShim from "../../_dnt.shims.js";
+import { z } from "zod";
+import { dynamicTool, tool } from "./factory.js";
+import type { JsonSchema } from "./schema/json-schema.js";
+import type { Tool, ToolConfig, ToolExecutionContext } from "./types.js";
+
+export interface HostToolDefinition {
+  description: string;
+  inputSchema: z.ZodSchema<unknown>;
+  inputSchemaJson?: JsonSchema;
+  execute: (input: unknown, context: ToolExecutionContext) => Promise<unknown> | unknown;
+  mcp?: ToolConfig["mcp"];
+}
+
+export interface HostToolMaterializationOptions {
+  generateToolCallId?: (toolName: string) => string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isZodSchema(value: unknown): value is z.ZodSchema<unknown> {
+  if (!isRecord(value) || typeof value.parse !== "function") return false;
+  if (!isRecord(value._def)) return false;
+  return typeof value._def.typeName === "string" || typeof value._def.type === "string";
+}
+
+function isHostToolDefinition(value: unknown): value is HostToolDefinition {
+  return (
+    isRecord(value) &&
+    typeof value.description === "string" &&
+    isZodSchema(value.inputSchema) &&
+    typeof value.execute === "function"
+  );
+}
+
+function defaultToolCallId(toolName: string): string {
+  return `${toolName}-${dntShim.crypto.randomUUID()}`;
+}
+
+function normalizeExecutionContext(
+  toolName: string,
+  context: ToolExecutionContext | undefined,
+  options: HostToolMaterializationOptions,
+): ToolExecutionContext {
+  const toolCallId = typeof context?.toolCallId === "string" && context.toolCallId.length > 0
+    ? context.toolCallId
+    : (options.generateToolCallId ?? defaultToolCallId)(toolName);
+
+  return {
+    ...(isRecord(context) ? context : {}),
+    toolCallId,
+  };
+}
+
+export function createToolsFromHostDefinitions(
+  definitions: Record<string, unknown>,
+  options: HostToolMaterializationOptions = {},
+): Record<string, Tool<unknown, unknown>> {
+  const tools: Record<string, Tool<unknown, unknown>> = {};
+
+  for (const [toolName, definition] of Object.entries(definitions)) {
+    if (!isHostToolDefinition(definition)) continue;
+
+    const execute = async (input: unknown, context: ToolExecutionContext | undefined) =>
+      await definition.execute(input, normalizeExecutionContext(toolName, context, options));
+
+    try {
+      tools[toolName] = definition.inputSchemaJson
+        ? dynamicTool({
+          id: toolName,
+          description: definition.description,
+          inputSchema: definition.inputSchema,
+          inputSchemaJson: definition.inputSchemaJson,
+          execute,
+          mcp: definition.mcp,
+        })
+        : tool({
+          id: toolName,
+          description: definition.description,
+          inputSchema: definition.inputSchema,
+          execute,
+          mcp: definition.mcp,
+        });
+    } catch {
+      continue;
+    }
+  }
+
+  return tools;
+}

package/src/src/tool/index.ts

@@ -60,6 +60,8 @@ export { createRemoteMCPToolSource } from "./remote-mcp.js";
 export type { RemoteMCPToolSourceConfig } from "./remote-mcp.js";
 export { createContext7ToolSource } from "./context7.js";
 export type { Context7ToolSourceConfig } from "./context7.js";
+export { createToolsFromHostDefinitions } from "./host-tools.js";
+export type { HostToolDefinition, HostToolMaterializationOptions } from "./host-tools.js";
 export {
   createToolsFromRemoteDefinitions,
   loadRemoteToolsFromSource,

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.321";
+export const VERSION = "0.1.323";