@standardagents/spec 0.21.1 → 0.22.1

package/dist/index.js

@@ -1,4 +1,107 @@
 // src/models.ts
+function providerValue(value) {
+  return { type: "const", value };
+}
+function providerEnv(name, options = {}) {
+  return { type: "env", name, ...options };
+}
+var providerConst = providerValue;
+function defineProvider(definition) {
+  if (!definition.name) {
+    throw new Error("Provider name is required");
+  }
+  if (typeof definition.baseProvider !== "function") {
+    throw new Error("baseProvider must be a provider factory function");
+  }
+  const factory = ((config) => {
+    const baseProvider = definition.baseProvider(config);
+    const commonContext = {
+      providerName: definition.name,
+      config,
+      baseProvider
+    };
+    const provider = {
+      name: definition.name,
+      specificationVersion: "1",
+      generate: (request) => {
+        const next = () => baseProvider.generate(request);
+        return Promise.resolve(definition.overrides?.generate?.({ ...commonContext, request }, next) ?? next());
+      },
+      stream: (request) => {
+        const next = () => baseProvider.stream(request);
+        return Promise.resolve(definition.overrides?.stream?.({ ...commonContext, request }, next) ?? next());
+      }
+    };
+    if (definition.overrides?.supportsModel || baseProvider.supportsModel) {
+      provider.supportsModel = (modelId) => {
+        const next = () => baseProvider.supportsModel?.(modelId) ?? true;
+        return definition.overrides?.supportsModel?.({ ...commonContext, modelId }, next) ?? next();
+      };
+    }
+    if (definition.overrides?.getModels || baseProvider.getModels) {
+      provider.getModels = (filter) => {
+        const next = () => baseProvider.getModels?.(filter) ?? Promise.resolve([]);
+        return Promise.resolve(
+          definition.overrides?.getModels?.({ ...commonContext, filter }, next) ?? next()
+        );
+      };
+    }
+    if (definition.overrides?.getModelsPage || baseProvider.getModelsPage) {
+      provider.getModelsPage = (query) => {
+        const next = () => baseProvider.getModelsPage?.(query) ?? Promise.resolve({ models: [], hasNextPage: false });
+        return Promise.resolve(
+          definition.overrides?.getModelsPage?.({ ...commonContext, query }, next) ?? next()
+        );
+      };
+    }
+    if (definition.overrides?.getModelCapabilities || baseProvider.getModelCapabilities) {
+      provider.getModelCapabilities = (modelId) => {
+        const next = () => baseProvider.getModelCapabilities?.(modelId) ?? Promise.resolve(null);
+        return Promise.resolve(
+          definition.overrides?.getModelCapabilities?.({ ...commonContext, modelId }, next) ?? next()
+        );
+      };
+    }
+    if (definition.overrides?.getTools || baseProvider.getTools) {
+      provider.getTools = (modelId) => {
+        const next = () => baseProvider.getTools?.(modelId) ?? {};
+        return definition.overrides?.getTools?.({ ...commonContext, modelId }, next) ?? next();
+      };
+    }
+    if (definition.overrides?.getIcon || baseProvider.getIcon) {
+      provider.getIcon = (modelId) => {
+        const next = () => baseProvider.getIcon?.(modelId);
+        return definition.overrides?.getIcon?.({ ...commonContext, modelId }, next) ?? next();
+      };
+    }
+    if (definition.overrides?.inspectRequest || baseProvider.inspectRequest) {
+      provider.inspectRequest = (request) => {
+        const next = () => {
+          if (!baseProvider.inspectRequest) {
+            throw new Error(`Provider '${definition.name}' does not support request inspection`);
+          }
+          return baseProvider.inspectRequest(request);
+        };
+        return Promise.resolve(
+          definition.overrides?.inspectRequest?.({ ...commonContext, request }, next) ?? next()
+        );
+      };
+    }
+    if (definition.overrides?.getResponseMetadata || baseProvider.getResponseMetadata) {
+      provider.getResponseMetadata = (summary, signal) => {
+        const next = () => baseProvider.getResponseMetadata?.(summary, signal) ?? Promise.resolve(null);
+        return Promise.resolve(
+          definition.overrides?.getResponseMetadata?.({ ...commonContext, summary, signal }, next) ?? next()
+        );
+      };
+    }
+    return provider;
+  });
+  factory.providerOptions = definition.baseProvider.providerOptions;
+  factory.configSlots = definition.baseProvider.configSlots;
+  factory.providerDefinition = definition;
+  return factory;
+}
 function defineModel(options) {
   if (!options.name) {
     throw new Error("Model name is required");
@@ -54,7 +157,8 @@ function defineTool(options) {
     tenvs: options.tenvs ?? null,
     executionMode: options.executionMode,
     executionProvider: options.executionProvider,
-    uses: options.uses
+    uses: options.uses,
+    progressArgument: options.progressArgument
   };
 }
 function extractVariablesFromTenvSchema(tenvSchema) {
@@ -138,7 +242,9 @@ var VALID_HOOKS = [
   "after_update_message",
   "before_store_tool_result",
   "after_tool_call_success",
-  "after_tool_call_failure"
+  "after_tool_call_failure",
+  "tool_call_started",
+  "tool_call_done"
 ];
 function defineHook(options) {
   if (!VALID_HOOKS.includes(options.hook)) {
@@ -245,6 +351,9 @@ function defineAgent(options) {
   };
 }
 
+// src/threads.ts
+var THREAD_STREAM_REASONING_PARAM = "reasoning";
+
 // src/endpoints.ts
 var THREAD_ENDPOINT_SYMBOL = Symbol.for("standardagents.threadEndpoint");
 function isThreadEndpoint(controller) {
@@ -310,6 +419,7 @@ function isVisibleInNamespace(metadata, namespace, isEntryPoint = false) {
 export {
   ProviderError,
   THREAD_ENDPOINT_SYMBOL,
+  THREAD_STREAM_REASONING_PARAM,
   belongsToPackage,
   defineAgent,
   defineController,
@@ -317,12 +427,16 @@ export {
   defineHook,
   defineModel,
   definePrompt,
+  defineProvider,
   defineThreadEndpoint,
   defineTool,
   isPacked,
   isThreadEndpoint,
   isVisibleInNamespace,
   mapReasoningLevel,
+  providerConst,
+  providerEnv,
+  providerValue,
   validateToolName
 };
 //# sourceMappingURL=index.js.map