@modelprofile.com/flexharness 10.13.0 → 10.15.0

package/ts/interfaces.ts

@@ -31,6 +31,8 @@ export type TFlexRetryReason = plugins.TAgentRetryReason;
  * Every call carries `provider` and `requestedModelId`; key usage caps on those two.
  */
 export type TFlexModelCallUsage = plugins.TAgentModelCallUsage;
+/** A model call's usage as harness events carry it: a reported call also states its cache hit ratio. */
+export type TFlexObservedModelCallUsage = plugins.TAgentObservedModelCallUsage;
 
 export interface IFlexTextPromptPart {
   type: 'text';
@@ -135,6 +137,8 @@ export interface IFlexToolMessagePart {
   output?: TJsonValue;
   error?: string;
   childSessionId?: string;
+  /** For a catalog call a `run_code` program made: the `run_code` call's ID. */
+  parentToolCallId?: string;
   model?: IFlexModelIdentity;
   /** ISO time the tool call began. Absent on parts recorded before part times existed. */
   startedAt?: string;
@@ -683,6 +687,9 @@ export const FLEX_TOOL_CATALOG_LIMITS = Object.freeze({
   maxDeclarationBytes: 16 * 1024,
   maxTags: 16,
   maxTagCharacters: 48,
+  maxAliases: 16,
+  maxAliasCharacters: 64,
+  maxVocabularyWords: 1024,
   maxExamples: 4,
   maxExampleBytes: 1024,
   maxSchemaBytes: 64 * 1024,
@@ -693,8 +700,16 @@ export const FLEX_TOOL_CATALOG_LIMITS = Object.freeze({
   maxDescribeTypes: 32,
   maxDescribeBytes: 64 * 1024,
   maxParamIssues: 10,
+  maxOutputTypeDepth: 32,
 });
 
+/**
+ * How many levels of named types a TypeScript declaration declares for a method's result by
+ * default: none. The result names its types, and `describe_tools({ types })` declares them on
+ * request, as a model needs them only to read fields of a result it has not seen.
+ */
+export const FLEX_TOOL_CATALOG_DEFAULT_OUTPUT_TYPE_DEPTH = 0;
+
 export interface IFlexCatalogSearchInput {
   /** Words to rank methods by. */
   query?: string;
@@ -743,6 +758,11 @@ export type TFlexCatalogCallError =
       more?: number;
       /** The lookup that returns the method's declaration. */
       see: string;
+    }
+  | {
+      error: 'denied';
+      method: string;
+      reason: string;
     };
 
 export interface IFlexCatalogToolDefinition {
@@ -761,7 +781,10 @@ export type TFlexCatalogSchema = { readonly [keyword: string]: unknown } | plugi
 export interface IFlexCatalogRunContext<TScope = unknown> {
   /** The dotted path the model called. */
   readonly method: string;
-  /** The `execute` call's ID; pass it with permission requests. */
+  /**
+   * The call's ID, which its tool part and permission requests carry: the `execute` call's, or for
+   * a call inside `run_code` the inner call's, `<run_code call ID>.<n>`.
+   */
   readonly toolCallId: string;
   readonly abortSignal: AbortSignal;
   /** The run's tool-provider context: scope, session, run and `requestPermission`. */
@@ -776,10 +799,16 @@ export interface IFlexCatalogMethod<TScope = unknown, TParams = any, TResult = u
   method: string;
   /** One line of at most 120 characters, shown in search results. */
   summary: string;
-  /** The full description, shown with the declaration. */
+  /** The full description, shown with the declaration. An empty or blank one counts as absent. */
   description?: string;
   /** More words `search_tools` matches. */
   tags?: readonly string[];
+  /**
+   * Other names of the method, such as the one its users' language or a former API gives it:
+   * `search_tools` weighs them like the method's name, and ranks the method first for a query that
+   * names one.
+   */
+  aliases?: readonly string[];
   /** Code shown as `@example` in the declaration. */
   examples?: readonly string[];
   /** The parameter object's schema; `execute` validates every call against it. */
@@ -797,22 +826,72 @@ export interface IFlexCatalogMethod<TScope = unknown, TParams = any, TResult = u
     params: TParams,
     context: IFlexCatalogRunContext<TScope>,
   ): TResult | PromiseLike<TResult> | AsyncIterable<TResult>;
+  /**
+   * Decides each validated call before it runs: `run` (the default without this hook), `propose`
+   * to hand it to the catalog's `onProposals` instead of running it, or `{ deny }` to refuse it.
+   */
+  onCall?(
+    params: TParams,
+    context: IFlexCatalogRunContext<TScope>,
+  ): TFlexCatalogCallDecision | PromiseLike<TFlexCatalogCallDecision>;
+}
+
+export type TFlexCatalogCallDecision = 'run' | 'propose' | { deny: string };
+
+/** A call a method's `onCall` decided to propose instead of running. */
+export interface IFlexCatalogProposal {
+  /** The call's ID: the `execute` call's, or the inner call's inside `run_code`. */
+  id: string;
+  method: string;
+  params: unknown;
+}
+
+export interface IFlexCatalogProposalContext<TScope = unknown> {
+  /** The `execute` or `run_code` call that made the proposals. */
+  readonly toolCallId: string;
+  readonly abortSignal: AbortSignal;
+  readonly provider: Readonly<IFlexToolProviderContext<TScope>>;
 }
 
 /** A named type that method declarations refer to; it needs a `declaration`, a `schema`, or both. */
 export interface IFlexCatalogType {
-  /** A JavaScript identifier such as `IMoney`. */
+  /**
+   * The type's name, such as `IMoney`, which `$ref`s to `#/$defs/<name>` use. A name that is no
+   * JavaScript identifier, such as `IEvent_order.created` as schema generators name instances of
+   * generics, is declared under an identifier made of it: each other character becomes `_`, and a
+   * reserved word or a leading digit is escaped with `_` (`IEvent_order_created`). Its declaration
+   * names the original, and `describe_tools` takes either.
+   */
   name: string;
+  /** An empty or blank description counts as absent. */
   description?: string;
   /** Validates parameters that refer to this type, and generates its declaration. */
   schema?: TFlexCatalogSchema;
-  /** Declaration text that replaces the generated one, such as `interface IMoney { … }`. */
+  /**
+   * Declaration text that replaces the generated one, such as `interface IMoney { … }`. It declares
+   * the identifier the type is declared under.
+   */
   declaration?: string;
 }
 
 export interface IFlexToolCatalog<TScope = unknown> {
   methods: readonly IFlexCatalogMethod<TScope>[];
   types?: readonly IFlexCatalogType[];
+  /**
+   * The words the catalog's users say for its own words, by the catalog's word:
+   * `{ voucher: ['Beleg', 'Belege'], 'gross amount': ['Bruttobetrag'] }`. A `search_tools` query that
+   * says every word of an alias searches for the catalog's words as well.
+   */
+  vocabulary?: Readonly<Record<string, readonly string[]>>;
+  /**
+   * Receives the calls `onCall` proposed, as one batch: the proposed call of an `execute`, or every
+   * call a `run_code` program proposed, once the program finished. A failed program proposes
+   * nothing. What it returns is what the model sees for them.
+   */
+  onProposals?(
+    proposals: readonly IFlexCatalogProposal[],
+    context: IFlexCatalogProposalContext<TScope>,
+  ): unknown;
 }
 
 export interface IFlexToolCatalogOptions {
@@ -821,8 +900,93 @@ export interface IFlexToolCatalogOptions {
    * across the session, or `json-schema` with each method's self-contained JSON Schema.
    */
   declarations?: 'typescript' | 'json-schema';
+  /**
+   * How many levels of named types a TypeScript declaration declares for a method's result:
+   * `0` (the default) none, `1` the types the result names, each further level the types those
+   * name. A parameter's types are always declared in full, since a call has to match them. The
+   * declaration lists the types it names but does not declare; `describe_tools({ types })`
+   * declares them on request.
+   */
+  outputTypeDepth?: number;
+  /**
+   * `search_tools` follows its results with the declaration of the top match when one match
+   * clearly leads, so the model can call it without a `describe_tools` step: the only match, or one
+   * whose name or alias the query names that ranks 1.25 times higher than the next. Default `true`.
+   */
+  describeTopMatch?: boolean;
+  /**
+   * Adds `run_code`, which runs a short TypeScript or JavaScript program against the catalog in a
+   * QuickJS sandbox. Needs the optional peers `quickjs-emscripten-core`,
+   * `@jitl/quickjs-ng-wasmfile-release-sync` and `amaro`.
+   */
+  codeMode?: boolean | IFlexCodeModeOptions;
+}
+
+export interface IFlexCodeModeOptions {
+  limits?: Partial<IFlexCodeModeLimits>;
 }
 
+/** The bounds of one `run_code` program. */
+export interface IFlexCodeModeLimits {
+  /** UTF-8 bytes of the program. */
+  maxSourceBytes: number;
+  /** Milliseconds the program may compute; time waiting for calls does not count. */
+  cpuMs: number;
+  /** Milliseconds the program may take in all, not counting waits for a permission decision. */
+  wallMs: number;
+  /** Bytes of the sandbox's heap. */
+  memoryBytes: number;
+  /**
+   * Bytes of the sandbox's stack. QuickJS runs on the host's stack as well, so a larger value lets
+   * deep recursion reach the host's limit first; the program then fails at its `stack` limit all
+   * the same.
+   */
+  stackBytes: number;
+  /** Catalog calls per program. */
+  maxCalls: number;
+  /** Catalog calls running at once; further calls wait for a slot. */
+  maxConcurrentCalls: number;
+  /** UTF-8 bytes of console output kept; more is cut off. */
+  maxLogBytes: number;
+}
+
+export const FLEX_CODE_MODE_TOOL_NAME = 'run_code';
+
+export const FLEX_CODE_MODE_DEFAULT_LIMITS: Readonly<IFlexCodeModeLimits> = Object.freeze({
+  maxSourceBytes: 32 * 1024,
+  cpuMs: 5_000,
+  wallMs: 60_000,
+  memoryBytes: 64 * 1024 * 1024,
+  stackBytes: 64 * 1024,
+  maxCalls: 200,
+  maxConcurrentCalls: 8,
+  maxLogBytes: 16 * 1024,
+});
+
+export const FLEX_CODE_MODE_MAXIMUM_LIMITS: Readonly<IFlexCodeModeLimits> = Object.freeze({
+  maxSourceBytes: 256 * 1024,
+  cpuMs: 60_000,
+  wallMs: 30 * 60_000,
+  memoryBytes: 512 * 1024 * 1024,
+  stackBytes: 256 * 1024,
+  maxCalls: 10_000,
+  maxConcurrentCalls: 64,
+  maxLogBytes: 256 * 1024,
+});
+
+/** What `run_code` reports to the model, as JSON, when a program does not finish. */
+export interface IFlexCodeRunFailure {
+  error: 'syntax_error' | 'program_error' | 'limit_exceeded' | 'aborted';
+  /** The limit that stopped the program, for `limit_exceeded`. */
+  limit?: 'source' | 'cpu' | 'wall' | 'memory' | 'stack' | 'calls';
+  name?: string;
+  message: string;
+  /** The program's line, when known. */
+  line?: number;
+  /** Catalog calls the program made. */
+  calls: number;
+  logs?: string;
+}
 export interface IFlexResourceToolProviderResolverContext<TScope> extends IFlexSessionGeneration {
   scopeId: string;
   scope: TScope;
@@ -1762,7 +1926,7 @@ export type TFlexModelUsageEvent = IFlexEventBase & {
   readonly type: 'model.usage';
   readonly runId?: string;
   readonly source: 'generation' | 'compaction';
-} & Readonly<TFlexModelCallUsage>;
+} & Readonly<TFlexObservedModelCallUsage>;
 
 export interface IFlexPromptQueueEvent extends IFlexEventBase {
   readonly type: 'prompt.queued' | 'prompt.started' | 'prompt.running' | 'prompt.finished';

package/ts/plugins.ts

@@ -13,6 +13,84 @@ import { Validator as JsonSchemaValidator } from '@cfworker/json-schema';
 export { asSchema, jsonSchema, JsonSchemaValidator };
 export type { FlexibleSchema, JSONSchema7, ModelMessage, Schema } from 'ai';
 
+// optional code mode peers: QuickJS-ng compiled to WebAssembly, and amaro to strip TypeScript types
+
+/** A value inside a QuickJS context; the host disposes every handle it owns. */
+export interface IQuickJsHandle {
+  readonly alive: boolean;
+  dispose(): void;
+}
+
+export type TQuickJsResult =
+  | { value: IQuickJsHandle; error?: undefined }
+  | { error: IQuickJsHandle; value?: undefined };
+
+export interface IQuickJsDeferredPromise {
+  readonly handle: IQuickJsHandle;
+  readonly alive: boolean;
+  resolve(value?: IQuickJsHandle): void;
+  reject(value?: IQuickJsHandle): void;
+  dispose(): void;
+}
+
+export interface IQuickJsContext {
+  readonly global: IQuickJsHandle;
+  newString(value: string): IQuickJsHandle;
+  getString(handle: IQuickJsHandle): string;
+  newFunction(name: string, implementation: (...args: IQuickJsHandle[]) => IQuickJsHandle | void): IQuickJsHandle;
+  setProp(target: IQuickJsHandle, key: string, value: IQuickJsHandle): void;
+  newPromise(): IQuickJsDeferredPromise;
+  newError(message: string): IQuickJsHandle;
+  evalCode(code: string, filename?: string): TQuickJsResult;
+  resolvePromise(handle: IQuickJsHandle): Promise<TQuickJsResult>;
+  dump(handle: IQuickJsHandle): unknown;
+  dispose(): void;
+}
+
+export interface IQuickJsRuntime {
+  readonly alive: boolean;
+  setMemoryLimit(bytes: number): void;
+  setMaxStackSize(bytes: number): void;
+  setInterruptHandler(handler: () => boolean): void;
+  newContext(): IQuickJsContext;
+  /** Runs the queued promise jobs; `error` is an exception none of them caught. */
+  executePendingJobs(): { error?: IQuickJsHandle };
+  dispose(): void;
+}
+
+export interface IQuickJsModule {
+  newRuntime(): IQuickJsRuntime;
+}
+
+/** A failed strip, as amaro reports it. */
+export interface IAmaroError {
+  code?: string;
+  message?: string;
+  startLine?: number;
+}
+
+export interface ICodeSandboxEngine {
+  /** A new WebAssembly instance of QuickJS-ng, with a memory of its own. */
+  newModule(): Promise<IQuickJsModule>;
+  /** Removes TypeScript type syntax, keeping every line where it was. */
+  stripTypes(source: string): string;
+}
+
+/** Loads QuickJS and amaro, the optional peers code mode needs. */
+export const importCodeSandboxEngine = async (): Promise<ICodeSandboxEngine> => {
+  const [core, variant, amaro] = await Promise.all([
+    import('quickjs-emscripten-core'),
+    import('@jitl/quickjs-ng-wasmfile-release-sync'),
+    import('amaro'),
+  ]);
+  // The variant's typings resolve as CommonJS; at run time the default export is the variant.
+  const quickjsVariant = (variant as { default: unknown }).default as Parameters<typeof core.newQuickJSWASMModuleFromVariant>[0];
+  return {
+    newModule: async () => await core.newQuickJSWASMModuleFromVariant(quickjsVariant) as unknown as IQuickJsModule,
+    stripTypes: (source) => amaro.transformSync(source, { mode: 'strip-only' }).code,
+  };
+};
+
 // @push.rocks scope
 import {
   AgentEventStoreConflictError,
@@ -80,6 +158,7 @@ export type {
   TAgentGenerationOutcome,
   TAgentModelCallUsage,
   TAgentModelCallUsageEvent,
+  TAgentObservedModelCallUsage,
   TAgentRetryReason,
   TAgentToolCallFinishEvent,
   TAgentToolExecutionReconciliationOptions,

package/ts/readme.md

@@ -1026,7 +1026,7 @@ A `contextCompactor` states which model to compact with from the model the compa
 
 A compactor uses `resolvedModel.model` directly, and resolves `modelHint` the way its model resolver resolves a prompt's `modelHint`. Only when neither member is present, because nothing dispatched states a model, does the host choose the compaction model itself.
 
-A `context-overflow` or `context-budget` compaction also carries `system` and `providerOptions`: the instructions and the provider options (cache options applied, so `store: false` on OpenAI) the run's turns are sent with. `compactMessages()` sends its summary call with them as one streamed call, the shape of every turn, so a compactor that passes its options through reaches the provider the way the run does. Without `system` it sends its own instructions.
+A `context-overflow` or `context-budget` compaction also carries `system` and `providerOptions`: the instructions and the provider options (cache options applied, so `store: false` on OpenAI) the run's turns are sent with. A `context-budget` compaction on a provider that caches the prefix also carries the turns' `tools`. `compactMessages()` sends its summary call with them as one streamed call, the shape of every turn, with the tools' definitions but none of their code, so a compactor that passes its options through repeats the run's prefix and reads it from the provider's prompt cache; definitions that outweigh the history nine times are left out. Without `system` it sends its own instructions.
 
 ```typescript
 agentSessionPolicy: {

package/ts/utils.harnessoptions.ts

@@ -1,6 +1,10 @@
 import { FlexHarnessValidationError } from './errors.js';
 import {
+  FLEX_CODE_MODE_DEFAULT_LIMITS,
+  FLEX_CODE_MODE_MAXIMUM_LIMITS,
   FLEX_REVERSION_DEFAULT_LIMITS,
+  FLEX_TOOL_CATALOG_DEFAULT_OUTPUT_TYPE_DEPTH,
+  FLEX_TOOL_CATALOG_LIMITS,
   FLEX_REVERSION_MAXIMUM_LIMITS,
 } from './interfaces.js';
 import type {
@@ -12,6 +16,7 @@ import type {
   IFlexReversionLimits,
   IFlexSlashCommandHandlerRegistration,
   IFlexSlashCommandTemplateRegistration,
+  IFlexCodeModeLimits,
   IFlexSubagentDefinition,
   IFlexToolCatalogOptions,
   TFlexSlashCommandRegistration,
@@ -157,25 +162,76 @@ export function normalizeSubagents(
   return Object.freeze(normalized);
 }
 
+export interface INormalizedToolCatalogOptions {
+  readonly declarations: 'typescript' | 'json-schema';
+  readonly outputTypeDepth: number;
+  readonly describeTopMatch: boolean;
+  /** The limits of `run_code`; absent while code mode is off. */
+  readonly codeMode?: Readonly<IFlexCodeModeLimits>;
+}
+
+const isPlainOptions = (value: unknown): value is Record<string, unknown> =>
+  !!value
+  && typeof value === 'object'
+  && !Array.isArray(value)
+  && [Object.prototype, null].includes(Object.getPrototypeOf(value));
+
 export function normalizeToolCatalogOptions(
-  options: IFlexHarnessOptions<unknown>['toolCatalog'],
-): Readonly<Required<IFlexToolCatalogOptions>> {
-  if (options === undefined) return Object.freeze({ declarations: 'typescript' });
-  if (
-    !options
-    || typeof options !== 'object'
-    || Array.isArray(options)
-    || ![Object.prototype, null].includes(Object.getPrototypeOf(options))
-  ) {
-    throw new FlexHarnessValidationError('toolCatalog must be a plain object.');
+  options: IFlexToolCatalogOptions | undefined,
+): INormalizedToolCatalogOptions {
+  if (options === undefined) {
+    return Object.freeze({
+      declarations: 'typescript',
+      outputTypeDepth: FLEX_TOOL_CATALOG_DEFAULT_OUTPUT_TYPE_DEPTH,
+      describeTopMatch: true,
+    });
   }
-  const unsupported = Object.keys(options).find((key) => key !== 'declarations');
+  if (!isPlainOptions(options)) throw new FlexHarnessValidationError('toolCatalog must be a plain object.');
+  const unsupported = Object.keys(options).find(
+    (key) => !['declarations', 'outputTypeDepth', 'describeTopMatch', 'codeMode'].includes(key),
+  );
   if (unsupported) throw new FlexHarnessValidationError(`toolCatalog does not support "${unsupported}".`);
   const declarations = options.declarations ?? 'typescript';
   if (declarations !== 'typescript' && declarations !== 'json-schema') {
     throw new FlexHarnessValidationError('toolCatalog.declarations must be "typescript" or "json-schema".');
   }
-  return Object.freeze({ declarations });
+  const outputTypeDepth: unknown = options.outputTypeDepth ?? FLEX_TOOL_CATALOG_DEFAULT_OUTPUT_TYPE_DEPTH;
+  if (
+    typeof outputTypeDepth !== 'number' || !Number.isSafeInteger(outputTypeDepth)
+    || outputTypeDepth < 0 || outputTypeDepth > FLEX_TOOL_CATALOG_LIMITS.maxOutputTypeDepth
+  ) {
+    throw new FlexHarnessValidationError(
+      `toolCatalog.outputTypeDepth must be an integer from 0 through ${FLEX_TOOL_CATALOG_LIMITS.maxOutputTypeDepth}.`,
+    );
+  }
+  const describeTopMatch = options.describeTopMatch ?? true;
+  if (typeof describeTopMatch !== 'boolean') throw new FlexHarnessValidationError('toolCatalog.describeTopMatch must be a boolean.');
+  const codeMode = normalizeCodeModeLimits(options.codeMode);
+  return Object.freeze({ declarations, outputTypeDepth, describeTopMatch, ...(codeMode ? { codeMode } : {}) });
+}
+
+function normalizeCodeModeLimits(codeMode: unknown): Readonly<IFlexCodeModeLimits> | undefined {
+  if (codeMode === undefined || codeMode === false) return undefined;
+  if (codeMode === true) return FLEX_CODE_MODE_DEFAULT_LIMITS;
+  if (!isPlainOptions(codeMode)) {
+    throw new FlexHarnessValidationError('toolCatalog.codeMode must be a boolean or a plain object.');
+  }
+  const unsupported = Object.keys(codeMode).find((key) => key !== 'limits');
+  if (unsupported) throw new FlexHarnessValidationError(`toolCatalog.codeMode does not support "${unsupported}".`);
+  const limits = codeMode.limits ?? {};
+  if (!isPlainOptions(limits)) throw new FlexHarnessValidationError('toolCatalog.codeMode.limits must be a plain object.');
+  const resolved: Record<string, number> = { ...FLEX_CODE_MODE_DEFAULT_LIMITS };
+  for (const [key, value] of Object.entries(limits)) {
+    if (!Object.prototype.hasOwnProperty.call(FLEX_CODE_MODE_MAXIMUM_LIMITS, key)) {
+      throw new FlexHarnessValidationError(`toolCatalog.codeMode.limits does not support "${key}".`);
+    }
+    const maximum = FLEX_CODE_MODE_MAXIMUM_LIMITS[key as keyof IFlexCodeModeLimits];
+    if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > maximum) {
+      throw new FlexHarnessValidationError(`toolCatalog.codeMode.limits.${key} must be an integer from 1 through ${maximum}.`);
+    }
+    resolved[key] = value;
+  }
+  return Object.freeze(resolved as unknown as IFlexCodeModeLimits);
 }
 
 export function normalizeBuiltInTools(

package/ts/utils.json.ts

@@ -785,6 +785,7 @@ function validateMessage(value: unknown, path: string): IValidatedMessageIdentit
           'output',
           'error',
           'childSessionId',
+          'parentToolCallId',
           'model',
           'startedAt',
           'completedAt',
@@ -801,6 +802,7 @@ function validateMessage(value: unknown, path: string): IValidatedMessageIdentit
       }
       requireOptionalString(part.error, `${partPath}.error`);
       requireOptionalString(part.childSessionId, `${partPath}.childSessionId`);
+      requireOptionalString(part.parentToolCallId, `${partPath}.parentToolCallId`);
       if (part.model !== undefined) validateModel(part.model, `${partPath}.model`);
       requireOptionalString(part.startedAt, `${partPath}.startedAt`);
       requireOptionalString(part.completedAt, `${partPath}.completedAt`);

package/ts/utils.tooloutput.ts

@@ -25,6 +25,15 @@ async function* normalizeAsyncIterable(
   }
 }
 
+/** A tool output's final value: the value itself, or the last value an async iterable yields. */
+export async function settleToolOutput(output: unknown): Promise<unknown> {
+  const value = await output;
+  if (!isAsyncIterable(value)) return value;
+  let last: unknown;
+  for await (const item of value) last = item;
+  return last;
+}
+
 export function wrapToolSet(
   tools: TFlexAgentToolSet,
   limits: Required<NonNullable<IFlexHarnessOptions<unknown>['toolOutputLimits']>>,

package/ts_compaction/plugins.ts

@@ -1,8 +1,8 @@
-import { streamText, wrapLanguageModel } from 'ai';
+import { asSchema, streamText, wrapLanguageModel } from 'ai';
 
-export { streamText, wrapLanguageModel };
+export { asSchema, streamText, wrapLanguageModel };
 
-export type { ModelMessage } from 'ai';
+export type { ModelMessage, ToolSet } from 'ai';
 export type { TSmartAiLanguageModel } from '@modelprofile.com/flexharness-models';
 
 import { AgentModelCallUsageRecorder } from '@modelprofile.com/flexharness-agent';