@alvin0/ai-agent-sdk-core 0.1.0

package/dist/runtime/registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.js","names":[],"sources":["../../src/runtime/registry.ts"],"sourcesContent":["/**\n * The adapter registry and the streaming call API.\n *\n * This is the deepseek-harness `LlmRuntime` with its dependency-injection\n * framework removed: a plain `Map` for routes, an ordered array for the\n * interception point that was a cordis waterfall, and a listener set for the\n * topology event. What is kept is everything that made it trustworthy  E * all-or-nothing validating registration, an atomic route swap, prepare/dispatch\n * generation binding, and a single failure funnel at the adapter boundary.\n *\n * @module ai-agent-sdk/core/runtime/registry\n */\n\nimport type { ModelAdapter } from '../contract/adapter.ts'\nimport {\n  callConfigEquals,\n  type CallConfig,\n  type CallConfigAdapterDefaults,\n} from '../contract/call-config.ts'\nimport type { GenerateOptions } from '../contract/generate-options.ts'\nimport type {\n  ModelContext,\n  ModelCatalogOptions,\n  ModelCatalogSnapshot,\n  ModelInfo,\n  ModelModality,\n  ProviderInfo,\n  ResolvedModelInfo,\n} from '../contract/model-info.ts'\nimport { resolveRetryPolicy, type ResolvedRetryPolicy } from '../contract/retry-policy.ts'\nimport { ModelError, REGISTRY_ERROR_CODES } from '../errors/model-error.ts'\nimport { deepFreeze } from '../primitives/freeze.ts'\nimport { SDK_VERSION } from '../primitives/version.ts'\nimport type { ObservationResource } from '../observation/event.ts'\nimport type { ObservationPort } from '../observation/port.ts'\nimport type { ModelCallHandle, ModelInvocationContext } from '../observation/report.ts'\nimport type { StreamChunk } from '../stream/chunk.ts'\nimport { createModelCallHandle } from './model-call-handle.ts'\nimport { normalizeResolvedModelInfo, resolveCallWithModelInfo,\n  validateCatalogModels, validateModelCatalogSnapshot } from './model-metadata.ts'\nimport { streamAdapter, type PreparedDispatch,\n  type RuntimeAdapterRegistration } from './model-stream.ts'\nimport {\n  PLUGIN_ERROR_CODES,\n  PluginError,\n  type AdapterRegistrationHandle,\n  type ModelProviderPlugin,\n  type ModelProviderRegistrar,\n  type PluginRegistrationHandle,\n  type StreamMiddleware,\n} from '../plugin/provider-plugin.ts'\n\nexport type { AdapterRegistrationHandle, StreamMiddleware } from '../plugin/provider-plugin.ts'\n\n/**\n * Wraps every streaming model call. Call `next()` to reach the adapter, or yield\n * your own chunks to short-circuit it entirely.\n *\n * This is the extension point for retry, caching, request logging, replay, and\n * test doubles. Middleware registered EARLIER sits further out.\n */\n/** One call whose configuration and adapter registration were resolved together. */\nexport interface PreparedCall {\n  /** Detached, deep-frozen config with any adapter-owned default materialized. */\n  readonly config: CallConfig\n  /** Immutable retry policy captured with the adapter registration. */\n  readonly retryPolicy: ResolvedRetryPolicy\n  /** Context capacity resolved with the registration-bound call. */\n  readonly context?: ModelContext\n  /** Exact model modalities captured with the dispatch generation. */\n  readonly inputModalities?: readonly ModelModality[]\n  /** Complete validated capability snapshot bound to this adapter generation. */\n  readonly model: ResolvedModelInfo\n  /** Which config fields the adapter supplied rather than the caller. */\n  readonly adapterDefaults: CallConfigAdapterDefaults\n  /**\n   * Dispatch this call ONCE, through the registration captured at preparation.\n   * @param options - the assembled request, carrying the prepared config.\n   * @returns the chunk stream, including middleware.\n   */\n  stream(options: GenerateOptions, context?: ModelInvocationContext): ModelCallHandle\n}\n\nexport interface ModelRegistryOptions {\n  /** Maximum model rows accepted from one adapter catalog. Defaults to 2,048. */\n  readonly maxCatalogModels?: number\n  /** Maximum serialized bytes accepted from a catalog or model-info record. Defaults to 4 MiB. */\n  readonly maxCatalogBytes?: number\n  /** Default observation port; a per-call invocation context may override it. */\n  readonly observation?: ObservationPort\n  /** Safe SDK/service/runtime identity copied onto observation events. */\n  readonly observationResource?: ObservationResource\n}\n\ntype AdapterRegistration = RuntimeAdapterRegistration\n\ninterface InstalledPlugin {\n  readonly routes: ReadonlySet<string>\n  readonly registrations: readonly AdapterRegistration[]\n  readonly middleware: readonly StreamMiddleware[]\n  readonly cleanup?: () => void\n}\n\n\nfunction containThenable(value: unknown): boolean {\n  if ((typeof value !== 'object' || value === null) && typeof value !== 'function') return false\n  let then: unknown\n  try {\n    then = Reflect.get(value, 'then')\n  } catch {\n    return true\n  }\n  if (typeof then !== 'function') return false\n  try { void Promise.resolve(value).catch(() => {}) } catch { /* hostile thenable contained */ }\n  return true\n}\n\nfunction synchronousCleanupFailure(cleanup: () => void): unknown | undefined {\n  try {\n    const result: unknown = cleanup()\n    return containThenable(result) ? new TypeError('plugin cleanup must be synchronous') : undefined\n  } catch (error) {\n    return error\n  }\n}\n\n\n/**\n * Routes model calls to registered adapters.\n *\n * Construct one per application or isolated runtime scope, register the adapters\n * you use, then call {@link stream} or {@link prepareCall}.\n */\nexport class ModelRegistry {\n  private adapters = new Map<string, AdapterRegistration>()\n  private middleware: StreamMiddleware[] = []\n  private listeners = new Set<() => void>()\n  private plugins = new Map<string, InstalledPlugin>()\n  private readonly maxCatalogModels: number\n  private readonly maxCatalogBytes: number\n  private readonly observation: ObservationPort | undefined\n  private readonly observationResource: ObservationResource\n\n  constructor(options: ModelRegistryOptions = {}) {\n    this.maxCatalogModels = positiveSafeInteger(options.maxCatalogModels ?? 2_048, 'maxCatalogModels')\n    this.maxCatalogBytes = positiveSafeInteger(options.maxCatalogBytes ?? 4 * 1024 * 1024, 'maxCatalogBytes')\n    this.observation = options.observation\n    this.observationResource = deepFreeze(options.observationResource ?? {\n      sdkName: 'ai-agent-sdk',\n      sdkVersion: SDK_VERSION,\n      runtime: 'unknown',\n    })\n  }\n\n  /** Install one provider plugin as a single synchronous topology transaction. */\n  install(plugin: ModelProviderPlugin): PluginRegistrationHandle {\n    const pluginId = typeof plugin?.id === 'string' ? plugin.id : ''\n    const fail = (message: string, cause?: unknown, cleanupFailures: readonly unknown[] = []): never => {\n      const causes = [...cause === undefined ? [] : [cause], ...cleanupFailures]\n      const wrappedCause = causes.length <= 1 ? causes[0] : new AggregateError(causes, `plugin ${pluginId} install cleanup failed`)\n      throw new PluginError(message, PLUGIN_ERROR_CODES.INSTALL_FAILED, pluginId, wrappedCause === undefined ? undefined : { cause: wrappedCause })\n    }\n    if (pluginId.trim().length === 0 || pluginId !== pluginId.trim()) fail('plugin id must be a non-empty trimmed string')\n    if (this.plugins.has(pluginId)) fail(`plugin \"${pluginId}\" is already installed`)\n    if (typeof plugin.displayName !== 'string' || plugin.displayName.trim().length === 0) fail(`plugin \"${pluginId}\" displayName must be non-empty`)\n    if (typeof plugin.setup !== 'function') fail(`plugin \"${pluginId}\" setup must be a function`)\n    const family = plugin.family ?? pluginId\n    if (typeof family !== 'string' || family.trim().length === 0 || family !== family.trim()) {\n      fail(`plugin \"${pluginId}\" family must be a non-empty trimmed string`)\n    }\n    const owner = Object.freeze({ pluginId, family })\n\n    interface StagedAdapter {\n      active: boolean\n      routes: string[]\n      readonly adapter: ModelAdapter\n    }\n    interface StagedMiddleware { active: boolean; readonly middleware: StreamMiddleware }\n    const stagedAdapters: StagedAdapter[] = []\n    const stagedMiddleware: StagedMiddleware[] = []\n    let staging = true\n\n    const registrar: ModelProviderRegistrar = {\n      registerAdapter: (routes, adapter) => {\n        if (!staging) fail(`plugin \"${pluginId}\" staging registrar is closed`)\n        if (routes.length === 0) throw new ModelError('an adapter must register at least one provider route', REGISTRY_ERROR_CODES.INVALID_ADAPTER)\n        const item: StagedAdapter = { active: true, routes: [...routes], adapter }\n        // Validate metadata and conflicts without mutating live routes.\n        const occupied = new Set(stagedAdapters.filter(value => value.active).flatMap(value => value.routes))\n        for (const route of routes) if (occupied.has(route)) {\n          throw new ModelError(`an adapter for provider route \"${route}\" is already staged`, REGISTRY_ERROR_CODES.DUPLICATE_ADAPTER)\n        }\n        this.prepareRoutes(routes, adapter, new Set(), owner)\n        stagedAdapters.push(item)\n        const handle = (() => {\n          if (staging) item.active = false\n        }) as AdapterRegistrationHandle\n        handle.replace = (next) => {\n          if (!staging || !item.active) throw new ModelError('a disposed staged registration cannot replace routes', REGISTRY_ERROR_CODES.REGISTRATION_DISPOSED)\n          const occupiedByOthers = new Set(stagedAdapters.filter(value => value.active && value !== item).flatMap(value => value.routes))\n          for (const route of next) if (occupiedByOthers.has(route)) {\n            throw new ModelError(`an adapter for provider route \"${route}\" is already staged`, REGISTRY_ERROR_CODES.DUPLICATE_ADAPTER)\n          }\n          this.prepareRoutes(next, adapter, new Set(), owner)\n          item.routes = [...next]\n        }\n        return handle\n      },\n      use: (middleware) => {\n        if (!staging) fail(`plugin \"${pluginId}\" staging registrar is closed`)\n        if (typeof middleware !== 'function') throw new TypeError('plugin middleware must be a function')\n        const item: StagedMiddleware = { active: true, middleware }\n        stagedMiddleware.push(item)\n        return () => { if (staging) item.active = false }\n      },\n    }\n\n    let cleanup: (() => void) | undefined\n    try {\n      const result = plugin.setup(registrar)\n      if (containThenable(result)) fail(`plugin \"${pluginId}\" setup must be synchronous`)\n      if (result !== undefined && typeof result !== 'function') fail(`plugin \"${pluginId}\" setup must be synchronous and return void or cleanup`)\n      cleanup = typeof result === 'function' ? result : undefined\n    } catch (error) {\n      if (error instanceof PluginError && error.code === PLUGIN_ERROR_CODES.INSTALL_FAILED) throw error\n      fail(`plugin \"${pluginId}\" setup failed`, error)\n    } finally {\n      staging = false\n    }\n\n    const registrations: AdapterRegistration[] = []\n    const routeNames = new Set<string>()\n    try {\n      for (const item of stagedAdapters) {\n        if (!item.active) continue\n        for (const route of item.routes) {\n          if (routeNames.has(route)) throw new ModelError(`an adapter for provider route \"${route}\" is already staged`, REGISTRY_ERROR_CODES.DUPLICATE_ADAPTER)\n          routeNames.add(route)\n        }\n        registrations.push(...this.prepareRoutes(item.routes, item.adapter, new Set(), owner))\n      }\n    } catch (error) {\n      const cleanupFailures: unknown[] = []\n      if (cleanup) {\n        const cleanupFailure = synchronousCleanupFailure(cleanup)\n        if (cleanupFailure !== undefined) cleanupFailures.push(cleanupFailure)\n      }\n      fail(`plugin \"${pluginId}\" commit validation failed`, error, cleanupFailures)\n    }\n\n    const committedMiddleware = stagedMiddleware.filter(item => item.active).map(item => item.middleware)\n    for (const registration of registrations) this.adapters.set(registration.provider.id, registration)\n    this.middleware.push(...committedMiddleware)\n    const installed: InstalledPlugin = {\n      routes: routeNames,\n      registrations,\n      middleware: committedMiddleware,\n      ...(cleanup === undefined ? {} : { cleanup }),\n    }\n    this.plugins.set(pluginId, installed)\n    this.emitAdaptersUpdated()\n\n    let disposed = false\n    const dispose = (() => {\n      if (disposed) return\n      disposed = true\n      this.plugins.delete(pluginId)\n      for (const registration of installed.registrations) {\n        if (this.adapters.get(registration.provider.id) === registration) this.adapters.delete(registration.provider.id)\n      }\n      for (let index = installed.middleware.length - 1; index >= 0; index--) {\n        const middleware = installed.middleware[index]\n        const liveIndex = middleware === undefined ? -1 : this.middleware.lastIndexOf(middleware)\n        if (liveIndex >= 0) this.middleware.splice(liveIndex, 1)\n      }\n      this.emitAdaptersUpdated()\n      const failures: unknown[] = []\n      if (installed.cleanup) {\n        const cleanupFailure = synchronousCleanupFailure(installed.cleanup)\n        if (cleanupFailure !== undefined) failures.push(cleanupFailure)\n      }\n      if (failures.length > 0) {\n        throw new PluginError(\n          `plugin \"${pluginId}\" cleanup failed`,\n          PLUGIN_ERROR_CODES.CLEANUP_FAILED,\n          pluginId,\n          { cause: new AggregateError(failures, `plugin \"${pluginId}\" cleanup failed`) },\n        )\n      }\n    }) as PluginRegistrationHandle\n    Object.defineProperty(dispose, 'pluginId', { value: pluginId, enumerable: true })\n    return dispose\n  }\n\n  /**\n   * Register an adapter for the given routes.\n   *\n   * All-or-nothing: if ANY route conflicts, nothing is registered. A partial\n   * registration would leave the caller believing a route exists when it does not.\n   * @param providers - every route this adapter should serve; must be non-empty.\n   * @param adapter - the adapter that streams calls for those routes.\n   * @returns the disposer, carrying {@link AdapterRegistrationHandle.replace}.\n   */\n  registerAdapter(\n    providers: readonly string[],\n    adapter: ModelAdapter,\n  ): AdapterRegistrationHandle {\n    if (providers.length === 0) {\n      throw new ModelError(\n        'an adapter must register at least one provider route',\n        REGISTRY_ERROR_CODES.INVALID_ADAPTER,\n      )\n    }\n    /** Routes this registration currently holds; `replace` rewrites it. */\n    const owned = new Set<string>()\n    // `owned` being empty cannot signal disposal on its own, because\n    // `replace([])` legally leaves a live registration holding no routes.\n    let released = false\n\n    this.commitRoutes(owned, this.prepareRoutes(providers, adapter, owned))\n\n    const handle = (() => {\n      if (released) return\n      released = true\n      for (const provider of owned) this.adapters.delete(provider)\n      owned.clear()\n      this.emitAdaptersUpdated()\n    }) as AdapterRegistrationHandle\n\n    handle.replace = (next: readonly string[]): void => {\n      // Registering after disposal would leak: nothing remains to release what\n      // this call would put back into the map.\n      if (released) {\n        throw new ModelError(\n          'a disposed adapter registration cannot replace its routes',\n          REGISTRY_ERROR_CODES.REGISTRATION_DISPOSED,\n        )\n      }\n      this.commitRoutes(owned, this.prepareRoutes(next, adapter, owned))\n    }\n    return handle\n  }\n\n  /**\n   * Validate one candidate route set, treating routes this registration already\n   * holds as available. Mutates nothing  Ea rejected candidate leaves the registry\n   * exactly as it was.\n   */\n  private prepareRoutes(\n    providers: readonly string[],\n    adapter: ModelAdapter,\n    owned: ReadonlySet<string>,\n    owner?: Readonly<{ pluginId: string; family: string }>,\n  ): AdapterRegistration[] {\n    const unique = new Set<string>()\n    const registrations: AdapterRegistration[] = []\n    for (const provider of providers) {\n      if (typeof provider !== 'string' || provider.length === 0) {\n        throw new ModelError(\n          'adapter provider route names must be non-empty strings',\n          REGISTRY_ERROR_CODES.INVALID_ADAPTER,\n        )\n      }\n      if (unique.has(provider) || (this.adapters.has(provider) && !owned.has(provider))) {\n        throw new ModelError(\n          `an adapter for provider route \"${provider}\" is already registered`,\n          REGISTRY_ERROR_CODES.DUPLICATE_ADAPTER,\n        )\n      }\n      const info = adapter.providerInfo(provider)\n      if (typeof info.id !== 'string' || info.id !== provider\n        || typeof info.name !== 'string' || info.name.length === 0) {\n        throw new ModelError(\n          `adapter metadata for route \"${provider}\" must preserve its id and carry a non-empty name`,\n          REGISTRY_ERROR_CODES.INVALID_ADAPTER,\n        )\n      }\n      unique.add(provider)\n      registrations.push({\n        adapter,\n        provider: { id: info.id, name: info.name },\n        ...(owner === undefined ? {} : owner),\n        // Captured at REGISTRATION time, not per call. An adapter whose policy\n        // follows mutable configuration re-registers via `handle.replace`.\n        retryPolicy: adapter.providerRetryPolicy(provider)\n          ?? resolveRetryPolicy(undefined, `provider \"${provider}\" retryPolicy`),\n      })\n    }\n    return registrations\n  }\n\n  /**\n   * Swap this registration's routes in ONE synchronous section, so no caller can\n   * observe the registry between the release and the re-registration.\n   */\n  private commitRoutes(\n    owned: Set<string>,\n    registrations: readonly AdapterRegistration[],\n  ): void {\n    for (const provider of owned) this.adapters.delete(provider)\n    owned.clear()\n    for (const registration of registrations) {\n      this.adapters.set(registration.provider.id, registration)\n      owned.add(registration.provider.id)\n    }\n    this.emitAdaptersUpdated()\n  }\n\n  /**\n   * Install streaming middleware.\n   * @param middleware - wrapper invoked around every call; earlier registrations sit further out.\n   * @returns a disposer that removes exactly this middleware.\n   */\n  use(middleware: StreamMiddleware): () => void {\n    this.middleware.push(middleware)\n    return () => {\n      const index = this.middleware.indexOf(middleware)\n      if (index >= 0) this.middleware.splice(index, 1)\n    }\n  }\n\n  /**\n   * Observe route-topology changes (registration, replacement, disposal).\n   * @param listener - payload-free notification; re-read `listProviders()` for new state.\n   * @returns a disposer that removes the listener.\n   */\n  onAdaptersUpdated(listener: () => void): () => void {\n    this.listeners.add(listener)\n    return () => void this.listeners.delete(listener)\n  }\n\n  /**\n   * Notify topology observers.\n   *\n   * Each listener is contained independently: a topology notification is not a\n   * veto, so one broken observer must not starve the others or roll back a\n   * registration that already happened.\n   */\n  private emitAdaptersUpdated(): void {\n    for (const listener of [...this.listeners]) {\n      try {\n        listener()\n      } catch {\n        // Contained deliberately; see above.\n      }\n    }\n  }\n\n  /**\n   * Describe every route with a registered adapter.\n   * @returns detached provider metadata, in registration order.\n   */\n  listProviders(): ProviderInfo[] {\n    return [...this.adapters.values()].map(({ provider }) => ({ ...provider }))\n  }\n\n  /**\n   * List the models one route advertises.\n   *\n   * Re-validated here rather than trusted, because a malformed catalog entry\n   * surfaces in a caller's model picker where its origin is far from obvious.\n   * @param provider - a registered route.\n   * @returns detached, validated model metadata.\n   */\n  async listModels(provider: string, signal?: AbortSignal): Promise<ModelInfo[]> {\n    const registration = this.registration(provider)\n    const models = await registration.adapter.listModels(provider, signal)\n    return validateCatalogModels(provider, models, this.maxCatalogModels, this.maxCatalogBytes)\n  }\n\n  /** Resolve and validate one uncached adapter-level catalog generation. */\n  async modelCatalog(provider: string, options: ModelCatalogOptions = {}): Promise<ModelCatalogSnapshot> {\n    const registration = this.registration(provider)\n    const snapshot = await registration.adapter.modelCatalog(provider, options)\n    return validateModelCatalogSnapshot(provider, snapshot, this.maxCatalogModels, this.maxCatalogBytes)\n  }\n\n  /**\n   * Resolve metadata for one exact model.\n   * @param provider - a registered route.\n   * @param model - exact model id.\n   * @param signal - cancellation for adapter-side resolution.\n   * @returns validated, detached metadata.\n   */\n  async resolveModelInfo(\n    provider: string,\n    model: string,\n    signal?: AbortSignal,\n  ): Promise<ResolvedModelInfo> {\n    const registration = this.registration(provider)\n    const resolved = await registration.adapter.resolveModel(provider, model, signal)\n    return normalizeResolvedModelInfo(registration.provider.id, model, resolved, this.maxCatalogBytes)\n  }\n\n  /** The retry policy captured for one route. */\n  retryPolicy(provider: string): ResolvedRetryPolicy {\n    return this.registration(provider).retryPolicy\n  }\n\n  /**\n   * Resolve one call under its CURRENT adapter registration, returning a one-shot\n   * handle that keeps that registration through to dispatch.\n   * @param config - route, model, and optional request controls.\n   * @param signal - cancellation for adapter-side capability lookup.\n   * @returns the prepared config and its registration-bound stream entry point.\n   */\n  async prepareCall(\n    config: CallConfig,\n    signal?: AbortSignal,\n    invocationContext?: ModelInvocationContext,\n  ): Promise<PreparedCall> {\n    const registration = this.registration(config.provider)\n    const adapterCall = await registration.adapter.prepareCall(config.provider, config.model, signal, invocationContext)\n    const modelInfo = normalizeResolvedModelInfo(\n      registration.provider.id, config.model, adapterCall.model, this.maxCatalogBytes,\n    )\n    const resolved = resolveCallWithModelInfo(config, modelInfo)\n    const resolvedConfig = deepFreeze(structuredClone(resolved.config))\n    const context = resolved.context === undefined\n      ? undefined\n      : deepFreeze(structuredClone(resolved.context))\n    const adapterDefaults = deepFreeze<CallConfigAdapterDefaults>({\n      ...config.reasoningEffort === undefined && resolvedConfig.reasoningEffort !== undefined\n        ? { reasoningEffort: true as const }\n        : {},\n      ...config.maxTokens === undefined && resolvedConfig.maxTokens !== undefined\n        ? { maxTokens: true as const }\n        : {},\n    })\n\n    let dispatched = false\n    const model = deepFreeze(structuredClone(modelInfo))\n    return Object.freeze({\n      config: resolvedConfig,\n      model,\n      retryPolicy: registration.retryPolicy,\n      adapterDefaults,\n      ...context === undefined ? {} : { context },\n      ...modelInfo.inputModalities === undefined\n        ? {}\n        : { inputModalities: Object.freeze([...modelInfo.inputModalities]) },\n      stream: (options: GenerateOptions, context = invocationContext): ModelCallHandle => {\n        // Both guards below exist so a stale handle fails loudly instead of\n        // quietly dispatching against a configuration nobody vetted.\n        if (dispatched) {\n          throw new ModelError(\n            'a prepared call can only be dispatched once',\n            REGISTRY_ERROR_CODES.INVALID_PREPARED_CALL,\n          )\n        }\n        if (!callConfigEquals(options, resolvedConfig)) {\n          throw new ModelError(\n            'prepared call config changed before adapter dispatch',\n            REGISTRY_ERROR_CODES.INVALID_PREPARED_CALL,\n          )\n        }\n        dispatched = true\n        return this.dispatch(options, context, {\n          registration,\n          config: resolvedConfig,\n          modelInfo,\n          dispatch: (request, activeContext) => adapterCall.stream(request, activeContext),\n        })\n      },\n    })\n  }\n\n  /**\n   * Stream one model call as raw chunks.\n   *\n   * Adapter selection, dispatch, and iteration failures become terminal `error` or\n   * `aborted` finish chunks. Middleware and consumer failures stay THROWN  Ethose\n   * are bugs in code the caller controls, and converting them to a finish reason\n   * would hide them.\n   * @param options - the full request; `options.provider` selects the adapter.\n   * @returns the chunk stream, wrapped by any installed middleware.\n   */\n  stream(options: GenerateOptions, context?: ModelInvocationContext): ModelCallHandle {\n    return this.dispatch(options, context)\n  }\n\n  private dispatch(\n    options: GenerateOptions,\n    context?: ModelInvocationContext,\n    prepared?: PreparedDispatch,\n  ): ModelCallHandle {\n    let dispatchState: 'not-sent' | 'unknown' = 'not-sent'\n    const registration = prepared?.registration ?? this.adapters.get(options.provider)\n    return createModelCallHandle({\n      options,\n      ...(registration?.family === undefined ? {} : { providerFamily: registration.family }),\n      ...(registration?.pluginId === undefined ? {} : { providerPluginId: registration.pluginId }),\n      ...(registration === undefined ? {} : { isRetryable: (code: string) => (\n        registration.retryPolicy.mode === 'always'\n          || registration.retryPolicy.retryableCodes.includes(code)\n      ) }),\n      ...(context === undefined ? {} : { context }),\n      ...(this.observation === undefined ? {} : { defaultObservation: this.observation }),\n      resource: this.observationResource,\n      routePresent: prepared !== undefined || this.adapters.has(options.provider),\n      dispatchState: () => dispatchState,\n      stream: activeContext => this.dispatchRaw(\n        options,\n        activeContext,\n        () => { dispatchState = 'unknown' },\n        prepared,\n      ),\n    })\n  }\n\n  /**\n   * Compose installed middleware around the adapter boundary.\n   *\n   * Composition is deferred to the first iteration rather than done eagerly, so\n   * that `stream()` ALWAYS returns an iterable and every failure — including a\n   * middleware that throws synchronously — surfaces on the same path. Composing\n   * eagerly would give callers two different error channels for the same class of\n   * fault, and they would inevitably handle only one.\n   *\n   * The middleware list is snapshotted here so that installing or removing\n   * middleware mid-stream cannot change the chain of a call already in flight.\n   */\n  private dispatchRaw(\n    options: GenerateOptions,\n    context: ModelInvocationContext,\n    onDispatch: () => void,\n    prepared?: PreparedDispatch,\n  ): AsyncIterable<StreamChunk> {\n    const chain = [...this.middleware]\n    const run = (): AsyncIterable<StreamChunk> => {\n      let next = (): AsyncIterable<StreamChunk> => streamAdapter({\n        options, context, onDispatch, maxCatalogBytes: this.maxCatalogBytes,\n        registration: provider => this.registration(provider),\n        registeredAdapter: provider => this.adapters.get(provider)?.adapter,\n        ...(prepared === undefined ? {} : { prepared }),\n      })\n      for (let index = chain.length - 1; index >= 0; index--) {\n        const middleware = chain[index]\n        if (middleware === undefined) continue\n        const inner = next\n        next = () => middleware(options, inner, context)\n      }\n      return next()\n    }\n    return {\n      async * [Symbol.asyncIterator]() {\n        yield* run()\n      },\n    }\n  }\n\n  private registration(provider: string): AdapterRegistration {\n    const registration = this.adapters.get(provider)\n    if (registration === undefined) {\n      throw new ModelError(\n        `no adapter registered for provider route \"${provider}\"`,\n        REGISTRY_ERROR_CODES.NO_ADAPTER,\n      )\n    }\n    return registration\n  }\n\n}\n\nfunction positiveSafeInteger(value: number, label: string): number {\n  if (!Number.isSafeInteger(value) || value < 1) {\n    throw new RangeError(`ModelRegistry ${label} must be a positive safe integer`)\n  }\n  return value\n}\n"],"mappings":"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"}

package/dist/runtime/with-retry.d.ts

@@ -0,0 +1,45 @@
+import { ModelFailure } from "../errors/failure.js";
+import { RetryPolicyConfig } from "../contract/retry-policy.js";
+import { ModelAdapter } from "../contract/adapter.js";
+//#region src/runtime/with-retry.d.ts
+/** One retry that is about to be waited out. */
+interface RetryAttempt {
+  /** The route whose call failed. */
+  readonly provider: string;
+  /** 1-based retry number. */
+  readonly attempt: number;
+  /** Retry ceiling, or `undefined` under an `always` policy. */
+  readonly maxRetries: number | undefined;
+  /** The failure being recovered from. */
+  readonly failure: ModelFailure;
+  /** How long the decorator will wait before re-dispatching. */
+  readonly delayMs: number;
+}
+/** Options for {@link withRetry}. */
+interface WithRetryOptions {
+  /**
+   * Policy to apply. Omission uses the wrapped adapter's own per-route policy,
+   * falling back to the shared defaults.
+   */
+  policy?: RetryPolicyConfig;
+  /** Sample in `[0, 1)` for jitter; injectable so tests can be deterministic. */
+  random?: () => number;
+  /** Observe each scheduled retry  Ethe hook for logging and metrics. */
+  onRetry?: (attempt: RetryAttempt) => void;
+  /** Maximum wait while closing an unsuccessful attempt. Defaults to 30s. */
+  teardownTimeoutMs?: number;
+}
+/**
+ * Wrap an adapter so eligible transient failures are retried with bounded
+ * exponential backoff and jitter.
+ *
+ * Only failures that occur BEFORE the first chunk reaches the consumer are
+ * retried; see the module note for why.
+ * @param adapter - the adapter to wrap; its metadata methods are delegated unchanged.
+ * @param options - policy, jitter source, and retry observer.
+ * @returns a new adapter with retry behaviour; the original is unmodified.
+ */
+declare function withRetry(adapter: ModelAdapter, options?: WithRetryOptions): ModelAdapter;
+//#endregion
+export { RetryAttempt, WithRetryOptions, withRetry };
+//# sourceMappingURL=with-retry.d.ts.map

package/dist/runtime/with-retry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-retry.d.ts","names":[],"sources":["../../src/runtime/with-retry.ts"],"mappings":";;;;;UAkCiB;;WAEN;;WAEA;;WAEA;;WAEA,SAAS;;WAET;;;UAIM;;;;;EAKf,SAAS;;EAET;;EAEA,WAAW,SAAS;;EAEpB;;;;;;;;;;;;iBAySc,UAAU,SAAS,cAAc,UAAS,mBAAwB"}

package/dist/runtime/with-retry.js

@@ -0,0 +1,2 @@
+import{waitForSettlement as e}from"../async/settlement.js";import{MODEL_ERROR_CODES as t,ModelError as n}from"../errors/model-error.js";import{normalizeModelFailure as r}from"../errors/failure.js";import{ModelAdapter as i}from"../contract/adapter.js";import{backoffDelayMs as a,resolveRetryPolicy as o}from"../contract/retry-policy.js";function s(e,t,n,r){let i=t.providerRetryAfterMs;return i!==void 0&&Number.isFinite(i)&&i>0?i<=e.maxDelayMs?i:e.mode===`always`?a(e,n,r):`give-up`:a(e,n,r)}function c(e,t){return t?.aborted===!0?Promise.resolve(!1):new Promise(n=>{let r=()=>{clearTimeout(i),n(!1)},i=setTimeout(()=>{t?.removeEventListener(`abort`,r),n(!0)},e);t?.addEventListener(`abort`,r,{once:!0})})}var l=class extends i{inner;options;constructor(e,t){super(),this.inner=e,this.options=t}providerInfo(e){return this.inner.providerInfo(e)}providerRetryPolicy(e){return this.inner.providerRetryPolicy(e)}listModels(e){return this.inner.listModels(e)}resolveModel(e,t,n){return this.inner.resolveModel(e,t,n)}async prepareCall(e,t,n,r){let i=await this.inner.prepareCall(e,t,n,r),a=this.policyFor(e);return{model:i.model,stream:(e,t=r)=>this.retryStream(e,e=>i.stream(e,t),a,t)}}stream(e,t){return this.retryStream(e,e=>this.inner.stream(e,t),this.policyFor(e.provider),t)}policyFor(e){return this.options.policy===void 0?this.inner.providerRetryPolicy(e)??o(void 0,`withRetry("${e}").policy`):o(this.options.policy,`withRetry("${e}").policy`)}async*retryStream(e,n,r,i){if(r.mode===`always`&&e.signal===void 0){yield{type:`finish`,reason:{kind:`error`,failure:{message:`an always retry policy requires an AbortSignal or deadline`,code:t.INVALID_REQUEST}}};return}let a=this.options.random??Math.random,o=0;for(;;){let l=await this.runAttempt(e,n);if(l.kind===`forward`){yield*l.chunks;return}let u=l.failure;if(e.signal?.aborted===!0||u.code===t.ABORTED){yield{type:`finish`,reason:{kind:`aborted`,failure:u}};return}if(!(r.mode===`always`||r.retryableCodes.includes(u.code)&&o<r.maxRetries)){yield{type:`finish`,reason:{kind:`error`,failure:u}};return}let d=s(r,u,o+1,a);if(d===`give-up`){yield{type:`finish`,reason:{kind:`error`,failure:u}};return}o+=1,i?.recordProviderRetry?.({nextAttemptNumber:o+1,delayMs:d,failureCode:u.code});try{this.options.onRetry?.({provider:e.provider,attempt:o,maxRetries:r.mode===`normal`?r.maxRetries:void 0,failure:u,delayMs:d})}catch{}if(!await c(d,e.signal)){yield{type:`finish`,reason:{kind:`aborted`,failure:{message:`model call aborted while waiting to retry`,code:t.ABORTED}}};return}}}async runAttempt(e,n){let i;try{i=n(e)[Symbol.asyncIterator]()}catch(e){return{kind:`retryable`,failure:r(e)}}let a;try{a=await i.next()}catch(e){return await f(i,this.options.teardownTimeoutMs??3e4),{kind:`retryable`,failure:r(e)}}if(a.done===!0)return{kind:`retryable`,failure:{message:`the adapter produced no chunks`,code:t.UNKNOWN}};let o=a.value;return o.type===`finish`&&o.reason.kind===`error`?(await f(i,this.options.teardownTimeoutMs??3e4),{kind:`retryable`,failure:o.reason.failure}):{kind:`forward`,chunks:d(o,i,this.options.teardownTimeoutMs??3e4)}}};function u(e,t){if(!Number.isFinite(e)||e<=0)throw RangeError(`${t} must be a positive finite number`);return e}async function*d(e,t,n){let r=!1;try{for(yield e;;){let e=await t.next();if(e.done===!0){r=!0;return}yield e.value}}finally{r||await f(t,n)}}async function f(r,i){let a=r.return?.();if(a!==void 0&&!await e(Promise.resolve(a),u(i,`withRetry teardownTimeoutMs`)))throw new n(`retry attempt teardown exceeded ${i}ms`,t.TEARDOWN_TIMEOUT)}function p(e,t={}){return new l(e,t)}export{p as withRetry};
+//# sourceMappingURL=with-retry.js.map

package/dist/runtime/with-retry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"with-retry.js","names":[],"sources":["../../src/runtime/with-retry.ts"],"sourcesContent":["/**\n * Retry as an adapter DECORATOR.\n *\n * In deepseek-harness this was a plugin on the agent loop's failed-step hook,\n * which let it restart a whole step and recover its attempt count from a durable\n * session log. A standalone SDK has neither, so retry moves down to the adapter\n * and holds its attempt count in the call's own closure.\n *\n * That relocation brings one hard constraint, and it is the thing to understand\n * about this module: a retry may only happen while NOTHING has been yielded\n * downstream yet. Once a text delta has reached the consumer, re-running the\n * request would replay those tokens and the consumer would render them twice.\n * So a failure that arrives mid-stream is forwarded, not retried  Erecovering\n * from it requires re-running the whole turn, which only the caller can decide.\n *\n * @module ai-agent-sdk/core/runtime/with-retry\n */\n\nimport { ModelAdapter, type PreparedAdapterCall } from '../contract/adapter.ts'\nimport type { GenerateOptions } from '../contract/generate-options.ts'\nimport type { ModelInfo, ResolvedModelInfo } from '../contract/model-info.ts'\nimport {\n  backoffDelayMs,\n  resolveRetryPolicy,\n  type ResolvedRetryPolicy,\n  type RetryPolicyConfig,\n} from '../contract/retry-policy.ts'\nimport { normalizeModelFailure, type ModelFailure } from '../errors/failure.ts'\nimport { MODEL_ERROR_CODES, ModelError } from '../errors/model-error.ts'\nimport type { StreamChunk } from '../stream/chunk.ts'\nimport type { ModelInvocationContext } from '../observation/report.ts'\nimport { waitForSettlement } from '../async/settlement.ts'\n\n/** One retry that is about to be waited out. */\nexport interface RetryAttempt {\n  /** The route whose call failed. */\n  readonly provider: string\n  /** 1-based retry number. */\n  readonly attempt: number\n  /** Retry ceiling, or `undefined` under an `always` policy. */\n  readonly maxRetries: number | undefined\n  /** The failure being recovered from. */\n  readonly failure: ModelFailure\n  /** How long the decorator will wait before re-dispatching. */\n  readonly delayMs: number\n}\n\n/** Options for {@link withRetry}. */\nexport interface WithRetryOptions {\n  /**\n   * Policy to apply. Omission uses the wrapped adapter's own per-route policy,\n   * falling back to the shared defaults.\n   */\n  policy?: RetryPolicyConfig\n  /** Sample in `[0, 1)` for jitter; injectable so tests can be deterministic. */\n  random?: () => number\n  /** Observe each scheduled retry  Ethe hook for logging and metrics. */\n  onRetry?: (attempt: RetryAttempt) => void\n  /** Maximum wait while closing an unsuccessful attempt. Defaults to 30s. */\n  teardownTimeoutMs?: number\n}\n\n/** Resolve a delay that honours a provider-requested `retry-after` when sane. */\nfunction delayFor(\n  policy: ResolvedRetryPolicy,\n  failure: ModelFailure,\n  attempt: number,\n  random: () => number,\n): number | 'give-up' {\n  const requested = failure.providerRetryAfterMs\n  if (requested !== undefined && Number.isFinite(requested) && requested > 0) {\n    if (requested <= policy.maxDelayMs) return requested\n    // The provider asked for longer than this policy is willing to wait. Under a\n    // bounded policy that is a refusal: sleeping less than asked would just earn\n    // another rate-limit response. An `always` policy has nowhere to give up to,\n    // so it falls back to local backoff and keeps trying.\n    return policy.mode === 'always' ? backoffDelayMs(policy, attempt, random) : 'give-up'\n  }\n  return backoffDelayMs(policy, attempt, random)\n}\n\n/** Sleep, resolving early and reporting false if the signal aborts first. */\nfunction cancellableDelay(delayMs: number, signal?: AbortSignal): Promise<boolean> {\n  if (signal?.aborted === true) return Promise.resolve(false)\n  return new Promise((resolve) => {\n    const onAbort = (): void => {\n      clearTimeout(timer)\n      resolve(false)\n    }\n    const timer = setTimeout(() => {\n      signal?.removeEventListener('abort', onAbort)\n      resolve(true)\n    }, delayMs)\n    signal?.addEventListener('abort', onAbort, { once: true })\n  })\n}\n\nclass RetryingAdapter extends ModelAdapter {\n  private readonly inner: ModelAdapter\n  private readonly options: WithRetryOptions\n\n  // Explicit fields rather than constructor parameter properties: Node's\n  // strip-only TypeScript mode rejects those, and this package is meant to run\n  // under `node file.ts` without a build step.\n  constructor(inner: ModelAdapter, options: WithRetryOptions) {\n    super()\n    this.inner = inner\n    this.options = options\n  }\n\n  override providerInfo(provider: string): ReturnType<ModelAdapter['providerInfo']> {\n    return this.inner.providerInfo(provider)\n  }\n\n  override providerRetryPolicy(provider: string): ResolvedRetryPolicy | undefined {\n    return this.inner.providerRetryPolicy(provider)\n  }\n\n  override listModels(provider: string): Promise<readonly ModelInfo[]> {\n    return this.inner.listModels(provider)\n  }\n\n  override resolveModel(\n    provider: string,\n    model: string,\n    signal?: AbortSignal,\n  ): Promise<ResolvedModelInfo> {\n    return this.inner.resolveModel(provider, model, signal)\n  }\n\n  override async prepareCall(\n    provider: string,\n    model: string,\n    signal?: AbortSignal,\n    context?: ModelInvocationContext,\n  ): Promise<PreparedAdapterCall> {\n    const prepared = await this.inner.prepareCall(provider, model, signal, context)\n    const policy = this.policyFor(provider)\n    return {\n      model: prepared.model,\n      // Retries reuse the SAME prepared generation. Re-preparing mid-retry could\n      // pair a fresh endpoint with capabilities resolved against the old one,\n      // which is exactly what the prepare/dispatch binding exists to prevent.\n      stream: (options, invocation = context) => this.retryStream(options, request => prepared.stream(request, invocation), policy, invocation),\n    }\n  }\n\n  stream(options: GenerateOptions, context?: ModelInvocationContext): AsyncIterable<StreamChunk> {\n    return this.retryStream(\n      options,\n      request => this.inner.stream(request, context),\n      this.policyFor(options.provider),\n      context,\n    )\n  }\n\n  private policyFor(provider: string): ResolvedRetryPolicy {\n    if (this.options.policy !== undefined) {\n      return resolveRetryPolicy(this.options.policy, `withRetry(\"${provider}\").policy`)\n    }\n    return this.inner.providerRetryPolicy(provider)\n      ?? resolveRetryPolicy(undefined, `withRetry(\"${provider}\").policy`)\n  }\n\n  private async * retryStream(\n    options: GenerateOptions,\n    dispatch: (request: GenerateOptions) => AsyncIterable<StreamChunk>,\n    policy: ResolvedRetryPolicy,\n    context?: ModelInvocationContext,\n  ): AsyncGenerator<StreamChunk> {\n    if (policy.mode === 'always' && options.signal === undefined) {\n      yield {\n        type: 'finish',\n        reason: {\n          kind: 'error',\n          failure: {\n            message: 'an always retry policy requires an AbortSignal or deadline',\n            code: MODEL_ERROR_CODES.INVALID_REQUEST,\n          },\n        },\n      }\n      return\n    }\n    const random = this.options.random ?? Math.random\n    let retries = 0\n\n    while (true) {\n      const attempt = await this.runAttempt(options, dispatch)\n      if (attempt.kind === 'forward') {\n        yield* attempt.chunks\n        return\n      }\n\n      const failure = attempt.failure\n      // An abort is the caller's decision, never a transient fault.\n      if (options.signal?.aborted === true || failure.code === MODEL_ERROR_CODES.ABORTED) {\n        yield { type: 'finish', reason: { kind: 'aborted', failure } }\n        return\n      }\n\n      const eligible = policy.mode === 'always'\n        || (policy.retryableCodes.includes(failure.code) && retries < policy.maxRetries)\n      if (!eligible) {\n        yield { type: 'finish', reason: { kind: 'error', failure } }\n        return\n      }\n\n      const delayMs = delayFor(policy, failure, retries + 1, random)\n      if (delayMs === 'give-up') {\n        yield { type: 'finish', reason: { kind: 'error', failure } }\n        return\n      }\n\n      retries += 1\n      context?.recordProviderRetry?.({\n        nextAttemptNumber: retries + 1,\n        delayMs,\n        failureCode: failure.code,\n      })\n      try {\n        this.options.onRetry?.({\n          provider: options.provider,\n          attempt: retries,\n          maxRetries: policy.mode === 'normal' ? policy.maxRetries : undefined,\n          failure,\n          delayMs,\n        })\n      } catch {\n        // Metrics/logging observers do not own request availability.\n      }\n      if (!await cancellableDelay(delayMs, options.signal)) {\n        yield {\n          type: 'finish',\n          reason: {\n            kind: 'aborted',\n            failure: {\n              message: 'model call aborted while waiting to retry',\n              code: MODEL_ERROR_CODES.ABORTED,\n            },\n          },\n        }\n        return\n      }\n    }\n  }\n\n  /**\n   * Run one attempt WITHOUT yielding anything downstream.\n   *\n   * Buffering is what makes retry safe: until the attempt either produces its\n   * first chunk or fails, nothing has been committed to the consumer. Once a\n   * chunk exists the attempt is no longer retryable, so it switches to\n   * `forward` and streams the rest through untouched.\n   */\n  private async runAttempt(\n    options: GenerateOptions,\n    dispatch: (request: GenerateOptions) => AsyncIterable<StreamChunk>,\n  ): Promise<\n    | { kind: 'forward'; chunks: AsyncIterable<StreamChunk> }\n    | { kind: 'retryable'; failure: ModelFailure }\n  > {\n    let iterator: AsyncIterator<StreamChunk>\n    try {\n      iterator = dispatch(options)[Symbol.asyncIterator]()\n    } catch (error: unknown) {\n      return { kind: 'retryable', failure: normalizeModelFailure(error) }\n    }\n\n    let first: IteratorResult<StreamChunk>\n    try {\n      first = await iterator.next()\n    } catch (error: unknown) {\n      await closeIterator(iterator, this.options.teardownTimeoutMs ?? 30_000)\n      return { kind: 'retryable', failure: normalizeModelFailure(error) }\n    }\n\n    // A stream that ends with no chunks at all told us nothing; treat it as the\n    // degenerate empty response rather than a silently successful turn.\n    if (first.done === true) {\n      return {\n        kind: 'retryable',\n        failure: {\n          message: 'the adapter produced no chunks',\n          code: MODEL_ERROR_CODES.UNKNOWN,\n        },\n      }\n    }\n\n    // An adapter behind the registry's funnel reports failure as a terminal\n    // error finish rather than a throw. As the FIRST chunk, that is still a\n    // clean nothing-emitted failure and remains retryable.\n    const chunk = first.value\n    if (chunk.type === 'finish' && chunk.reason.kind === 'error') {\n      await closeIterator(iterator, this.options.teardownTimeoutMs ?? 30_000)\n      return { kind: 'retryable', failure: chunk.reason.failure }\n    }\n\n    return {\n      kind: 'forward',\n      chunks: resume(chunk, iterator, this.options.teardownTimeoutMs ?? 30_000),\n    }\n  }\n}\n\nfunction positiveFinite(value: number, name: string): number {\n  if (!Number.isFinite(value) || value <= 0) throw new RangeError(`${name} must be a positive finite number`)\n  return value\n}\n\n/** Re-attach an already-read first chunk to the front of its iterator. */\nasync function* resume(\n  first: StreamChunk,\n  iterator: AsyncIterator<StreamChunk>,\n  teardownTimeoutMs: number,\n): AsyncGenerator<StreamChunk> {\n  let exhausted = false\n  try {\n    yield first\n    while (true) {\n      const next = await iterator.next()\n      if (next.done === true) {\n        exhausted = true\n        return\n      }\n      yield next.value\n    }\n  } finally {\n    if (!exhausted) await closeIterator(iterator, teardownTimeoutMs)\n  }\n}\n\nasync function closeIterator(iterator: AsyncIterator<StreamChunk>, timeoutMs: number): Promise<void> {\n  const closing = iterator.return?.()\n  if (closing === undefined) return\n  const settled = await waitForSettlement(\n    Promise.resolve(closing),\n    positiveFinite(timeoutMs, 'withRetry teardownTimeoutMs'),\n  )\n  if (!settled) {\n    throw new ModelError(\n      `retry attempt teardown exceeded ${timeoutMs}ms`,\n      MODEL_ERROR_CODES.TEARDOWN_TIMEOUT,\n    )\n  }\n}\n\n/**\n * Wrap an adapter so eligible transient failures are retried with bounded\n * exponential backoff and jitter.\n *\n * Only failures that occur BEFORE the first chunk reaches the consumer are\n * retried; see the module note for why.\n * @param adapter - the adapter to wrap; its metadata methods are delegated unchanged.\n * @param options - policy, jitter source, and retry observer.\n * @returns a new adapter with retry behaviour; the original is unmodified.\n */\nexport function withRetry(adapter: ModelAdapter, options: WithRetryOptions = {}): ModelAdapter {\n  return new RetryingAdapter(adapter, options)\n}\n"],"mappings":"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"}

package/dist/skills.d.ts

@@ -0,0 +1,8 @@
+import { SdkLogger } from "./logging/types.js";
+import { MAX_SKILL_DESCRIPTION_CHARS, MAX_SKILL_ID_CHARS, MAX_SKILL_INSTRUCTIONS_CHARS, MAX_SKILL_NAME_CHARS, MAX_SKILL_RESOURCE_CHARS, MAX_SKILL_RESOURCE_PATH_CHARS, SKILL_ID_PATTERN, SkillCandidate, SkillDefinition, SkillDefinitionInput, SkillInvocationPolicy, SkillLookupOptions, SkillProvider, SkillProviderListOptions, SkillResourceBase, SkillResourceSummary, SkillSource, SkillSummary, defineSkill, defineSkillProvider, validateCandidate, validateSkillId, validateSkillResourcePath, validateSkillSource } from "./agent/skill/definition.js";
+import { SKILL_ERROR_CODES, SKILL_PROVIDER_API_VERSION } from "./agent/skill/provider/config.js";
+import { ActivatedSkillSnapshot, RuntimeSkillCandidate, RuntimeSkillLookupOptions, RuntimeSkillSource, SkillCatalogSnapshot, SkillProviderDefinition, SkillProviderPlugin, SkillProviderPluginDefinition, SkillReference } from "./agent/skill/provider/types.js";
+import { SkillCatalog, SkillCatalogOptions } from "./agent/skill/catalog.js";
+import { AgentSkillOptions, ResolvedAgentSkillOptions, SKILL_TOOL_NAMES, createSkillTools, renderSkillCatalog, resolveSkillOptions } from "./agent/skill/tools.js";
+import { defineSkillProviderPlugin } from "./agent/skill/provider/definition.js";
+export { type ActivatedSkillSnapshot, type AgentSkillOptions, MAX_SKILL_DESCRIPTION_CHARS, MAX_SKILL_ID_CHARS, MAX_SKILL_INSTRUCTIONS_CHARS, MAX_SKILL_NAME_CHARS, MAX_SKILL_RESOURCE_CHARS, MAX_SKILL_RESOURCE_PATH_CHARS, type ResolvedAgentSkillOptions, type RuntimeSkillCandidate, type RuntimeSkillLookupOptions, type RuntimeSkillSource, SKILL_ERROR_CODES, SKILL_ID_PATTERN, SKILL_PROVIDER_API_VERSION, SKILL_TOOL_NAMES, type SdkLogger, type SkillCandidate, SkillCatalog, type SkillCatalogOptions, type SkillCatalogSnapshot, type SkillDefinition, type SkillDefinitionInput, type SkillInvocationPolicy, type SkillLookupOptions, type SkillProvider, type SkillProviderDefinition, type SkillProviderListOptions, type SkillProviderPlugin, type SkillProviderPluginDefinition, type SkillReference, type SkillResourceBase, type SkillResourceSummary, type SkillSource, type SkillSummary, createSkillTools, defineSkill, defineSkillProvider, defineSkillProviderPlugin, renderSkillCatalog, resolveSkillOptions, validateCandidate, validateSkillId, validateSkillResourcePath, validateSkillSource };

package/dist/skills.js

@@ -0,0 +1 @@
+import{MAX_SKILL_DESCRIPTION_CHARS as e,MAX_SKILL_ID_CHARS as t,MAX_SKILL_INSTRUCTIONS_CHARS as n,MAX_SKILL_NAME_CHARS as r,MAX_SKILL_RESOURCE_CHARS as i,MAX_SKILL_RESOURCE_PATH_CHARS as a,SKILL_ID_PATTERN as o,defineSkill as s,defineSkillProvider as c,validateCandidate as l,validateSkillId as u,validateSkillResourcePath as d,validateSkillSource as f}from"./agent/skill/definition.js";import{SKILL_ERROR_CODES as p,SKILL_PROVIDER_API_VERSION as m}from"./agent/skill/provider/config.js";import{defineSkillProviderPlugin as h}from"./agent/skill/provider/definition.js";import{SkillCatalog as g}from"./agent/skill/catalog.js";import{SKILL_TOOL_NAMES as _,createSkillTools as v,renderSkillCatalog as y,resolveSkillOptions as b}from"./agent/skill/tools.js";export{e as MAX_SKILL_DESCRIPTION_CHARS,t as MAX_SKILL_ID_CHARS,n as MAX_SKILL_INSTRUCTIONS_CHARS,r as MAX_SKILL_NAME_CHARS,i as MAX_SKILL_RESOURCE_CHARS,a as MAX_SKILL_RESOURCE_PATH_CHARS,p as SKILL_ERROR_CODES,o as SKILL_ID_PATTERN,m as SKILL_PROVIDER_API_VERSION,_ as SKILL_TOOL_NAMES,g as SkillCatalog,v as createSkillTools,s as defineSkill,c as defineSkillProvider,h as defineSkillProviderPlugin,y as renderSkillCatalog,b as resolveSkillOptions,l as validateCandidate,u as validateSkillId,d as validateSkillResourcePath,f as validateSkillSource};

package/dist/stream/assembler.d.ts

@@ -0,0 +1,86 @@
+import { ContentBlock } from "../message/content.js";
+import { FinishReason, ReplayEnvelope, StreamChunk, TokenUsage } from "./chunk.js";
+import { Message, MessageSource } from "../message/message.js";
+//#region src/stream/assembler.d.ts
+/**
+ * Incrementally assembles {@link StreamChunk}s into {@link ContentBlock}s and a
+ * final assistant {@link Message}.
+ *
+ * Tolerant by design: it accepts delta-only protocols that never send
+ * `block-start`, and it IGNORES deltas that arrive for an index already closed by
+ * `block-end`. That last rule is a containment boundary  Ea misbehaving adapter
+ * cannot grow memory without bound or corrupt a block a consumer has already
+ * been told is final.
+ */
+declare class BlockAssembler {
+  private partials;
+  /** Block indexes in FIRST-SEEN order; the stream's own ordering, not sorted. */
+  private order;
+  private _usage;
+  private _finish;
+  private _replayState;
+  /**
+   * Feed one chunk into the assembly state.
+   * @param chunk - the next chunk, in stream order.
+   */
+  push(chunk: StreamChunk): void;
+  private ensure;
+  private assemble;
+  /** Invariant accessor: every index in `order` has a partial. */
+  private mustGet;
+  /**
+   * The ONE keep/drop decision over all seen blocks, so emitted blocks and
+   * replay metadata cannot disagree about what survived.
+   *
+   * Max-token truncation drops tool calls: a call cut off mid-arguments has
+   * incomplete JSON, and executing it would act on arguments the model never
+   * finished choosing.
+   */
+  private assembled;
+  /**
+   * Assemble every block seen so far, in stream order.
+   * @returns one block per seen index, minus tool calls dropped by max-token
+   *   truncation. An open block assembles from its accumulated deltas.
+   */
+  blocks(): ContentBlock[];
+  /** Whether the canonical stream contains host tool calls, including calls
+   * dropped from blocks() on truncation. No incomplete arguments are parsed. */
+  get hasToolCalls(): boolean;
+  /** Canonical text blocks with their original stream indexes, in first-seen
+   * order. Shares first-close-wins semantics with blocks(), including ignored
+   * straggler deltas and authoritative block-end replacements. */
+  textBlocks(): {
+    index: number;
+    block: Extract<ContentBlock, {
+      type: 'text';
+    }>;
+    beforeNativeCall: boolean;
+  }[];
+  /**
+   * Assemble the prefix an INTERRUPTED stream can safely finalize: closed and
+   * open text/reasoning blocks carrying non-whitespace content.
+   *
+   * Tool calls are omitted because interruption precedes dispatch, so keeping one
+   * would oblige the caller to fabricate a result for a call that never ran.
+   * @returns the kept blocks; empty when nothing usable streamed first.
+   */
+  interruptedBlocks(): ContentBlock[];
+  /** Usage from the `usage` chunk; undefined until one arrives. */
+  get usage(): TokenUsage | undefined;
+  /** Finish reason; `{ kind: 'stop' }` when the stream ended without one. */
+  get finish(): FinishReason;
+  /**
+   * Replay metadata, with per-block entries pruned in step with {@link blocks}.
+   * Undefined when the envelope did not align with the emitted blocks.
+   */
+  get replayState(): ReplayEnvelope | undefined;
+  /**
+   * The assembled assistant message.
+   * @param source - producer attribution for the message.
+   * @returns a frozen assistant-role message over {@link blocks}.
+   */
+  message(source: MessageSource): Message;
+}
+//#endregion
+export { BlockAssembler };
+//# sourceMappingURL=assembler.d.ts.map

package/dist/stream/assembler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembler.d.ts","names":[],"sources":["../../src/stream/assembler.ts"],"mappings":";;;;;;;;;;;;;;cAuCa;UACH;;UAEA;UACA;UACA;UACA;;;;;EAMR,KAAK,OAAO;UAuDJ;UAUA;;UAyBA;;;;;;;;;UAgBA;;;;;;EA2BR,UAAU;;;MAMN;;;;EAUJ;IAAgB;IAAe,OAAO,QAAQ;MAAgB;;IAAiB;;;;;;;;;;EAqB/E,qBAAqB;;MAajB,SAAS;;MAKT,UAAU;;;;;MAQV,eAAe;;;;;;EASnB,QAAQ,QAAQ,gBAAgB"}

package/dist/stream/assembler.js

@@ -0,0 +1,2 @@
+import{ToolCallId as e}from"../primitives/brand.js";import{assertNever as t}from"../primitives/never.js";import{createMessage as n}from"../message/message.js";var r=class{partials=new Map;order=[];_usage;_finish;_replayState;push(e){switch(e.type){case`block-start`:this.partials.has(e.index)||(this.order.push(e.index),this.partials.set(e.index,{blockType:e.blockType,text:``,toolCallArguments:``}));return;case`text-delta`:case`reasoning-delta`:{let t=this.ensure(e.index,e.type===`text-delta`?`text`:`reasoning`);if(t.block!==void 0)return;t.text+=e.text,e.type===`text-delta`&&e.phase!==void 0&&(t.textPhase=e.phase);return}case`tool-call-delta`:{let t=this.ensure(e.index,`tool-call`);if(t.block!==void 0)return;t.toolCallId=e.id,e.name!==void 0&&e.name.length>0&&(t.toolCallName=e.name),t.toolCallArguments+=e.argumentsDelta;return}case`image-delta`:return;case`block-end`:{let t=this.ensure(e.index,e.block.type);if(t.block!==void 0)return;t.block=e.block;return}case`usage`:this._usage=e.usage;return;case`finish`:this._finish=e.reason,this._replayState=e.replayState;return;default:return t(e,`BlockAssembler.push`)}}ensure(e,t){let n=this.partials.get(e);return n===void 0&&(n={blockType:t,text:``,toolCallArguments:``},this.partials.set(e,n),this.order.push(e)),n}assemble(t,n){if(t.block!==void 0)return t.block;switch(t.blockType){case`text`:return{type:`text`,text:t.text,...t.textPhase===void 0?{}:{phase:t.textPhase}};case`reasoning`:return{type:`reasoning`,text:t.text};case`tool-call`:return{type:`tool-call`,id:t.toolCallId??e(`call-${n}`),name:t.toolCallName??``,arguments:t.toolCallArguments};default:throw Error(`cannot assemble incomplete block of type "${t.blockType}"`)}}mustGet(e){let t=this.partials.get(e);if(t===void 0)throw Error(`BlockAssembler invariant violated: no partial for index ${e}`);return t}assembled(){let e=this.order.map(e=>this.assemble(this.mustGet(e),e)),t=this.finish.kind===`max-tokens`?e.map(e=>e.type!==`tool-call`):void 0,n=t===void 0?e:e.filter((e,n)=>t[n]===!0),r=this._replayState;return r?.blocks===void 0?{blocks:n,replay:r}:r.blocks.length===e.length?{blocks:n,replay:t===void 0||n.length===e.length?r:{response:r.response,blocks:r.blocks.filter((e,n)=>t[n]===!0)}}:{blocks:n,replay:void 0}}blocks(){return this.assembled().blocks}get hasToolCalls(){return this.order.some(e=>{let t=this.mustGet(e);return(t.block?.type??t.blockType)===`tool-call`})}textBlocks(){let e=this.order.findLastIndex(e=>{let t=this.mustGet(e);return(t.block?.type??t.blockType)===`native-tool-call`});return this.order.flatMap((t,n)=>{let r=this.mustGet(t);if((r.block?.type??r.blockType)!==`text`)return[];let i=this.assemble(r,t);return i.type===`text`?[{index:t,block:i,beforeNativeCall:n<e}]:[]})}interruptedBlocks(){return this.order.map(e=>{let t=this.mustGet(e),n=t.block?.type??t.blockType;if(n===`text`||n===`reasoning`)return this.assemble(t,e)}).filter(e=>(e?.type===`text`||e?.type===`reasoning`)&&e.text.trim()!==``)}get usage(){return this._usage}get finish(){return this._finish??{kind:`stop`}}get replayState(){return this.assembled().replay}message(e){return n({role:`assistant`,content:this.blocks(),source:e})}};export{r as BlockAssembler};
+//# sourceMappingURL=assembler.js.map

package/dist/stream/assembler.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assembler.js","names":[],"sources":["../../src/stream/assembler.ts"],"sourcesContent":["/**\n * The single canonical chunk-to-message assembly algorithm.\n *\n * Every consumer that needs a finished message from a stream uses this, so that\n * \"what the user saw streaming\" and \"what got stored in history\" cannot drift\n * apart. Feed it every chunk, then read {@link BlockAssembler.blocks},\n * {@link BlockAssembler.message}, `usage`, and `finish` once the stream ends  Eor\n * {@link BlockAssembler.interruptedBlocks} when cancellation cut it short.\n *\n * @module ai-agent-sdk/core/stream/assembler\n */\n\nimport type { AssistantTextPhase, ContentBlock } from '../message/content.ts'\nimport { createMessage, type Message, type MessageSource } from '../message/message.ts'\nimport { ToolCallId } from '../primitives/brand.ts'\nimport { assertNever } from '../primitives/never.ts'\nimport type { FinishReason, ReplayEnvelope, StreamChunk, TokenUsage } from './chunk.ts'\n\ninterface PartialBlock {\n  blockType: string\n  text: string\n  textPhase?: AssistantTextPhase\n  toolCallId?: ToolCallId\n  toolCallName?: string\n  toolCallArguments: string\n  /** Set by `block-end`  Eauthoritative, and freezes this partial against further deltas. */\n  block?: ContentBlock\n}\n\n/**\n * Incrementally assembles {@link StreamChunk}s into {@link ContentBlock}s and a\n * final assistant {@link Message}.\n *\n * Tolerant by design: it accepts delta-only protocols that never send\n * `block-start`, and it IGNORES deltas that arrive for an index already closed by\n * `block-end`. That last rule is a containment boundary  Ea misbehaving adapter\n * cannot grow memory without bound or corrupt a block a consumer has already\n * been told is final.\n */\nexport class BlockAssembler {\n  private partials = new Map<number, PartialBlock>()\n  /** Block indexes in FIRST-SEEN order; the stream's own ordering, not sorted. */\n  private order: number[] = []\n  private _usage: TokenUsage | undefined\n  private _finish: FinishReason | undefined\n  private _replayState: ReplayEnvelope | undefined\n\n  /**\n   * Feed one chunk into the assembly state.\n   * @param chunk - the next chunk, in stream order.\n   */\n  push(chunk: StreamChunk): void {\n    switch (chunk.type) {\n      case 'block-start': {\n        if (!this.partials.has(chunk.index)) {\n          this.order.push(chunk.index)\n          this.partials.set(chunk.index, {\n            blockType: chunk.blockType,\n            text: '',\n            toolCallArguments: '',\n          })\n        }\n        return\n      }\n      case 'text-delta':\n      case 'reasoning-delta': {\n        const partial = this.ensure(chunk.index, chunk.type === 'text-delta' ? 'text' : 'reasoning')\n        if (partial.block !== undefined) return // closed by block-end; ignore stragglers\n        partial.text += chunk.text\n        if (chunk.type === 'text-delta' && chunk.phase !== undefined) partial.textPhase = chunk.phase\n        return\n      }\n      case 'tool-call-delta': {\n        const partial = this.ensure(chunk.index, 'tool-call')\n        if (partial.block !== undefined) return // closed by block-end; ignore stragglers\n        partial.toolCallId = chunk.id\n        if (chunk.name !== undefined && chunk.name.length > 0) partial.toolCallName = chunk.name\n        partial.toolCallArguments += chunk.argumentsDelta\n        return\n      }\n      case 'image-delta':\n        // Progressive images are presentation-only. The authoritative final\n        // image arrives inside the native-tool-call `block-end`.\n        return\n      case 'block-end': {\n        const partial = this.ensure(chunk.index, chunk.block.type)\n        // First close wins. Ignoring re-close stragglers keeps the streamed\n        // output and the final assembled block in agreement.\n        if (partial.block !== undefined) return\n        partial.block = chunk.block\n        return\n      }\n      case 'usage': {\n        this._usage = chunk.usage\n        return\n      }\n      case 'finish': {\n        this._finish = chunk.reason\n        this._replayState = chunk.replayState\n        return\n      }\n      default:\n        return assertNever(chunk, 'BlockAssembler.push')\n    }\n  }\n\n  private ensure(index: number, blockType: string): PartialBlock {\n    let partial = this.partials.get(index)\n    if (partial === undefined) {\n      partial = { blockType, text: '', toolCallArguments: '' }\n      this.partials.set(index, partial)\n      this.order.push(index)\n    }\n    return partial\n  }\n\n  private assemble(partial: PartialBlock, index: number): ContentBlock {\n    if (partial.block !== undefined) return partial.block\n    switch (partial.blockType) {\n      case 'text': return {\n        type: 'text',\n        text: partial.text,\n        ...partial.textPhase === undefined ? {} : { phase: partial.textPhase },\n      }\n      case 'reasoning': return { type: 'reasoning', text: partial.text }\n      case 'tool-call': return {\n        type: 'tool-call',\n        // A synthesized id keeps the result correlatable even from a provider\n        // that only sent the id on a chunk we never received.\n        id: partial.toolCallId ?? ToolCallId(`call-${index}`),\n        name: partial.toolCallName ?? '',\n        arguments: partial.toolCallArguments,\n      }\n      default:\n        // An extension block type that never received its authoritative\n        // `block-end`: only the adapter that invented it knows how to build one.\n        throw new Error(`cannot assemble incomplete block of type \"${partial.blockType}\"`)\n    }\n  }\n\n  /** Invariant accessor: every index in `order` has a partial. */\n  private mustGet(index: number): PartialBlock {\n    const partial = this.partials.get(index)\n    if (partial === undefined) {\n      throw new Error(`BlockAssembler invariant violated: no partial for index ${index}`)\n    }\n    return partial\n  }\n\n  /**\n   * The ONE keep/drop decision over all seen blocks, so emitted blocks and\n   * replay metadata cannot disagree about what survived.\n   *\n   * Max-token truncation drops tool calls: a call cut off mid-arguments has\n   * incomplete JSON, and executing it would act on arguments the model never\n   * finished choosing.\n   */\n  private assembled(): { blocks: ContentBlock[]; replay: ReplayEnvelope | undefined } {\n    const all = this.order.map(index => this.assemble(this.mustGet(index), index))\n    const kept = this.finish.kind === 'max-tokens'\n      ? all.map(block => block.type !== 'tool-call')\n      : undefined\n    const blocks = kept === undefined ? all : all.filter((_, position) => kept[position] === true)\n    const envelope = this._replayState\n    if (envelope?.blocks === undefined) return { blocks, replay: envelope }\n    // A per-block envelope that does not line up with the blocks it describes is\n    // discarded whole: a misaligned mapping is worse than no mapping.\n    if (envelope.blocks.length !== all.length) return { blocks, replay: undefined }\n    return {\n      blocks,\n      replay: kept === undefined || blocks.length === all.length\n        ? envelope\n        : {\n          response: envelope.response,\n          blocks: envelope.blocks.filter((_, position) => kept[position] === true),\n        },\n    }\n  }\n\n  /**\n   * Assemble every block seen so far, in stream order.\n   * @returns one block per seen index, minus tool calls dropped by max-token\n   *   truncation. An open block assembles from its accumulated deltas.\n   */\n  blocks(): ContentBlock[] {\n    return this.assembled().blocks\n  }\n\n  /** Whether the canonical stream contains host tool calls, including calls\n   * dropped from blocks() on truncation. No incomplete arguments are parsed. */\n  get hasToolCalls(): boolean {\n    return this.order.some(index => {\n      const partial = this.mustGet(index)\n      return (partial.block?.type ?? partial.blockType) === 'tool-call'\n    })\n  }\n\n  /** Canonical text blocks with their original stream indexes, in first-seen\n   * order. Shares first-close-wins semantics with blocks(), including ignored\n   * straggler deltas and authoritative block-end replacements. */\n  textBlocks(): { index: number; block: Extract<ContentBlock, { type: 'text' }>; beforeNativeCall: boolean }[] {\n    const lastNative = this.order.findLastIndex(index => {\n      const partial = this.mustGet(index)\n      return (partial.block?.type ?? partial.blockType) === 'native-tool-call'\n    })\n    return this.order.flatMap((index, position) => {\n      const partial = this.mustGet(index)\n      if ((partial.block?.type ?? partial.blockType) !== 'text') return []\n      const block = this.assemble(partial, index)\n      return block.type === 'text' ? [{ index, block, beforeNativeCall: position < lastNative }] : []\n    })\n  }\n\n  /**\n   * Assemble the prefix an INTERRUPTED stream can safely finalize: closed and\n   * open text/reasoning blocks carrying non-whitespace content.\n   *\n   * Tool calls are omitted because interruption precedes dispatch, so keeping one\n   * would oblige the caller to fabricate a result for a call that never ran.\n   * @returns the kept blocks; empty when nothing usable streamed first.\n   */\n  interruptedBlocks(): ContentBlock[] {\n    return this.order\n      .map((index) => {\n        const partial = this.mustGet(index)\n        const type = partial.block?.type ?? partial.blockType\n        if (type !== 'text' && type !== 'reasoning') return undefined\n        return this.assemble(partial, index)\n      })\n      .filter((block): block is ContentBlock =>\n        (block?.type === 'text' || block?.type === 'reasoning') && block.text.trim() !== '')\n  }\n\n  /** Usage from the `usage` chunk; undefined until one arrives. */\n  get usage(): TokenUsage | undefined {\n    return this._usage\n  }\n\n  /** Finish reason; `{ kind: 'stop' }` when the stream ended without one. */\n  get finish(): FinishReason {\n    return this._finish ?? { kind: 'stop' }\n  }\n\n  /**\n   * Replay metadata, with per-block entries pruned in step with {@link blocks}.\n   * Undefined when the envelope did not align with the emitted blocks.\n   */\n  get replayState(): ReplayEnvelope | undefined {\n    return this.assembled().replay\n  }\n\n  /**\n   * The assembled assistant message.\n   * @param source - producer attribution for the message.\n   * @returns a frozen assistant-role message over {@link blocks}.\n   */\n  message(source: MessageSource): Message {\n    return createMessage({ role: 'assistant', content: this.blocks(), source })\n  }\n}\n"],"mappings":"+JAuCA,IAAa,EAAb,KAA4B,CAC1B,SAAmB,IAAI,IAEvB,MAA0B,CAAC,EAC3B,OACA,QACA,aAMA,KAAK,EAA0B,CAC7B,OAAQ,EAAM,KAAd,CACE,IAAK,cACE,KAAK,SAAS,IAAI,EAAM,KAAK,IAChC,KAAK,MAAM,KAAK,EAAM,KAAK,EAC3B,KAAK,SAAS,IAAI,EAAM,MAAO,CAC7B,UAAW,EAAM,UACjB,KAAM,GACN,kBAAmB,EACrB,CAAC,GAEH,OAEF,IAAK,aACL,IAAK,kBAAmB,CACtB,IAAM,EAAU,KAAK,OAAO,EAAM,MAAO,EAAM,OAAS,aAAe,OAAS,WAAW,EAC3F,GAAI,EAAQ,QAAU,IAAA,GAAW,OACjC,EAAQ,MAAQ,EAAM,KAClB,EAAM,OAAS,cAAgB,EAAM,QAAU,IAAA,KAAW,EAAQ,UAAY,EAAM,OACxF,MACF,CACA,IAAK,kBAAmB,CACtB,IAAM,EAAU,KAAK,OAAO,EAAM,MAAO,WAAW,EACpD,GAAI,EAAQ,QAAU,IAAA,GAAW,OACjC,EAAQ,WAAa,EAAM,GACvB,EAAM,OAAS,IAAA,IAAa,EAAM,KAAK,OAAS,IAAG,EAAQ,aAAe,EAAM,MACpF,EAAQ,mBAAqB,EAAM,eACnC,MACF,CACA,IAAK,cAGH,OACF,IAAK,YAAa,CAChB,IAAM,EAAU,KAAK,OAAO,EAAM,MAAO,EAAM,MAAM,IAAI,EAGzD,GAAI,EAAQ,QAAU,IAAA,GAAW,OACjC,EAAQ,MAAQ,EAAM,MACtB,MACF,CACA,IAAK,QACH,KAAK,OAAS,EAAM,MACpB,OAEF,IAAK,SACH,KAAK,QAAU,EAAM,OACrB,KAAK,aAAe,EAAM,YAC1B,OAEF,QACE,OAAO,EAAY,EAAO,qBAAqB,CACnD,CACF,CAEA,OAAe,EAAe,EAAiC,CAC7D,IAAI,EAAU,KAAK,SAAS,IAAI,CAAK,EAMrC,OALI,IAAY,IAAA,KACd,EAAU,CAAE,YAAW,KAAM,GAAI,kBAAmB,EAAG,EACvD,KAAK,SAAS,IAAI,EAAO,CAAO,EAChC,KAAK,MAAM,KAAK,CAAK,GAEhB,CACT,CAEA,SAAiB,EAAuB,EAA6B,CACnE,GAAI,EAAQ,QAAU,IAAA,GAAW,OAAO,EAAQ,MAChD,OAAQ,EAAQ,UAAhB,CACE,IAAK,OAAQ,MAAO,CAClB,KAAM,OACN,KAAM,EAAQ,KACd,GAAG,EAAQ,YAAc,IAAA,GAAY,CAAC,EAAI,CAAE,MAAO,EAAQ,SAAU,CACvE,EACA,IAAK,YAAa,MAAO,CAAE,KAAM,YAAa,KAAM,EAAQ,IAAK,EACjE,IAAK,YAAa,MAAO,CACvB,KAAM,YAGN,GAAI,EAAQ,YAAc,EAAW,QAAQ,GAAO,EACpD,KAAM,EAAQ,cAAgB,GAC9B,UAAW,EAAQ,iBACrB,EACA,QAGE,MAAU,MAAM,6CAA6C,EAAQ,UAAU,EAAE,CACrF,CACF,CAGA,QAAgB,EAA6B,CAC3C,IAAM,EAAU,KAAK,SAAS,IAAI,CAAK,EACvC,GAAI,IAAY,IAAA,GACd,MAAU,MAAM,2DAA2D,GAAO,EAEpF,OAAO,CACT,CAUA,WAAoF,CAClF,IAAM,EAAM,KAAK,MAAM,IAAI,GAAS,KAAK,SAAS,KAAK,QAAQ,CAAK,EAAG,CAAK,CAAC,EACvE,EAAO,KAAK,OAAO,OAAS,aAC9B,EAAI,IAAI,GAAS,EAAM,OAAS,WAAW,EAC3C,IAAA,GACE,EAAS,IAAS,IAAA,GAAY,EAAM,EAAI,QAAQ,EAAG,IAAa,EAAK,KAAc,EAAI,EACvF,EAAW,KAAK,aAKtB,OAJI,GAAU,SAAW,IAAA,GAAkB,CAAE,SAAQ,OAAQ,CAAS,EAGlE,EAAS,OAAO,SAAW,EAAI,OAC5B,CACL,SACA,OAAQ,IAAS,IAAA,IAAa,EAAO,SAAW,EAAI,OAChD,EACA,CACA,SAAU,EAAS,SACnB,OAAQ,EAAS,OAAO,QAAQ,EAAG,IAAa,EAAK,KAAc,EAAI,CACzE,CACJ,EATkD,CAAE,SAAQ,OAAQ,IAAA,EAAU,CAUhF,CAOA,QAAyB,CACvB,OAAO,KAAK,UAAU,CAAC,CAAC,MAC1B,CAIA,IAAI,cAAwB,CAC1B,OAAO,KAAK,MAAM,KAAK,GAAS,CAC9B,IAAM,EAAU,KAAK,QAAQ,CAAK,EAClC,OAAQ,EAAQ,OAAO,MAAQ,EAAQ,aAAe,WACxD,CAAC,CACH,CAKA,YAA6G,CAC3G,IAAM,EAAa,KAAK,MAAM,cAAc,GAAS,CACnD,IAAM,EAAU,KAAK,QAAQ,CAAK,EAClC,OAAQ,EAAQ,OAAO,MAAQ,EAAQ,aAAe,kBACxD,CAAC,EACD,OAAO,KAAK,MAAM,SAAS,EAAO,IAAa,CAC7C,IAAM,EAAU,KAAK,QAAQ,CAAK,EAClC,IAAK,EAAQ,OAAO,MAAQ,EAAQ,aAAe,OAAQ,MAAO,CAAC,EACnE,IAAM,EAAQ,KAAK,SAAS,EAAS,CAAK,EAC1C,OAAO,EAAM,OAAS,OAAS,CAAC,CAAE,QAAO,QAAO,iBAAkB,EAAW,CAAW,CAAC,EAAI,CAAC,CAChG,CAAC,CACH,CAUA,mBAAoC,CAClC,OAAO,KAAK,MACT,IAAK,GAAU,CACd,IAAM,EAAU,KAAK,QAAQ,CAAK,EAC5B,EAAO,EAAQ,OAAO,MAAQ,EAAQ,UACxC,OAAS,QAAU,IAAS,YAChC,OAAO,KAAK,SAAS,EAAS,CAAK,CACrC,CAAC,CAAC,CACD,OAAQ,IACN,GAAO,OAAS,QAAU,GAAO,OAAS,cAAgB,EAAM,KAAK,KAAK,IAAM,EAAE,CACzF,CAGA,IAAI,OAAgC,CAClC,OAAO,KAAK,MACd,CAGA,IAAI,QAAuB,CACzB,OAAO,KAAK,SAAW,CAAE,KAAM,MAAO,CACxC,CAMA,IAAI,aAA0C,CAC5C,OAAO,KAAK,UAAU,CAAC,CAAC,MAC1B,CAOA,QAAQ,EAAgC,CACtC,OAAO,EAAc,CAAE,KAAM,YAAa,QAAS,KAAK,OAAO,EAAG,QAAO,CAAC,CAC5E,CACF"}

package/dist/stream/chunk.d.ts

@@ -0,0 +1,135 @@
+import { ToolCallId } from "../primitives/brand.js";
+import { ModelFailure } from "../errors/failure.js";
+import { AssistantTextPhase, ContentBlock, ContentBlockType, ImageMediaType } from "../message/content.js";
+//#region src/stream/chunk.d.ts
+/**
+ * Why a model response stopped. Merge-extensible, so an adapter can surface a
+ * provider-specific reason without a core release.
+ *
+ * `aborted` and `error` carry their failure inline because a stream that fails
+ * still has to END — a thrown exception mid-iteration would strand whatever text
+ * had already been assembled.
+ */
+interface FinishReasonMap {
+  'stop': {
+    kind: 'stop';
+  };
+  'tool-calls': {
+    kind: 'tool-calls';
+  };
+  'max-tokens': {
+    kind: 'max-tokens';
+  };
+  'aborted': {
+    kind: 'aborted';
+    failure: ModelFailure;
+  };
+  'error': {
+    kind: 'error';
+    failure: ModelFailure;
+  };
+}
+/** Any known finish reason. Switch on `kind` and fall through unknowns. */
+type FinishReason = FinishReasonMap[keyof FinishReasonMap];
+/**
+ * Token accounting for one model call.
+ *
+ * Counts are DISJOINT, which is the one thing to get right here: `inputTokens` is
+ * UNCACHED input only, and cached input is reported separately, so billed input is
+ * the sum of the three. Providers disagree — some fold cache hits into a single
+ * prompt total — and the adapter subtracts them back out to honour this
+ * convention. Without it, every cost calculation double-counts cache hits.
+ */
+interface TokenUsage {
+  /** Uncached input tokens. */
+  inputTokens: number;
+  outputTokens: number;
+  /**
+   * Exact full-call total.
+   *
+   * Set only when authoritative: preserved from a provider total, or derived from
+   * aggregate counters that agree. Omitted rather than guessed.
+   */
+  totalTokens?: number;
+  cacheReadTokens?: number;
+  cacheWriteTokens?: number;
+  reasoningTokens?: number;
+}
+/**
+ * Adapter-private lossless-JSON state for replaying a successful response.
+ *
+ * Carried by the terminal `finish` chunk and stored on the assembled message.
+ * Both halves stay opaque above the adapter; only the SPLIT is shared vocabulary,
+ * which is what lets assembly keep stored metadata aligned with stored content
+ * without understanding either half.
+ */
+interface ReplayEnvelope {
+  /** Response-level adapter-private metadata (ids, native stop reason). */
+  response: unknown;
+  /**
+   * Per-block adapter-private metadata, one entry per emitted block in first-seen
+   * stream order.
+   *
+   * When assembly drops a block it drops the entry at the same position. An
+   * envelope whose length does not match the emitted block count is discarded
+   * whole, because a misaligned mapping is worse than none. An adapter whose
+   * metadata is independent of block structure omits this field.
+   */
+  blocks?: readonly unknown[];
+}
+/**
+ * The raw streaming protocol every adapter emits.
+ *
+ * Contract adapters must honour:
+ * - `index` correlates the deltas of interleaved blocks. It is adapter-assigned in
+ *   first-seen order and need not match any provider's own numbering.
+ * - `block-end` carries the AUTHORITATIVE assembled block, so a consumer that
+ *   trusts it never has to re-derive one from deltas.
+ * - `usage` precedes the terminal `finish`, and NOTHING follows `finish`.
+ * - tool arguments stay raw JSON strings.
+ *
+ * An adapter may throw, but the registry normalizes that into a terminal `error`
+ * or `aborted` finish before a consumer ever sees it.
+ */
+type StreamChunk = {
+  type: 'block-start';
+  index: number;
+  blockType: ContentBlockType;
+} | {
+  type: 'text-delta';
+  index: number;
+  text: string;
+  phase?: AssistantTextPhase;
+} | {
+  type: 'reasoning-delta';
+  index: number;
+  text: string;
+} | {
+  type: 'image-delta';
+  index: number;
+  itemId: string;
+  data: string;
+  mediaType: ImageMediaType;
+  partialIndex?: number;
+} | {
+  type: 'tool-call-delta';
+  index: number;
+  id: ToolCallId;
+  name?: string;
+  argumentsDelta: string;
+} | {
+  type: 'block-end';
+  index: number;
+  block: ContentBlock;
+} | {
+  type: 'usage';
+  usage: TokenUsage;
+} | {
+  type: 'finish';
+  reason: FinishReason;
+  /** Replay metadata for a successful response; see {@link ReplayEnvelope}. */
+  replayState?: ReplayEnvelope;
+};
+//#endregion
+export { FinishReason, FinishReasonMap, ReplayEnvelope, StreamChunk, TokenUsage };
+//# sourceMappingURL=chunk.d.ts.map

package/dist/stream/chunk.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","names":[],"sources":["../../src/stream/chunk.ts"],"mappings":";;;;;;;;;;;;UAkBiB;EACf;IAAU;;EACV;IAAgB;;EAChB;IAAgB;;EAChB;IAAa;IAAiB,SAAS;;EACvC;IAAW;IAAe,SAAS;;;;KAIzB,eAAe,sBAAsB;;;;;;;;;;UAWhC;;EAEf;EACA;;;;;;;EAOA;EACA;EACA;EACA;;;;;;;;;;UAWe;;EAEf;;;;;;;;;;EAUA;;;;;;;;;;;;;;;;KAiBU;EACN;EAAqB;EAAe,WAAW;;EAC/C;EAAoB;EAAe;EAAc,QAAQ;;EACzD;EAAyB;EAAe;;EAE1C;EACA;EACA;EACA;EACA,WAAW;EACX;;EAEE;EAAyB;EAAe,IAAI;EAAY;EAAe;;EACvE;EAAmB;EAAe,OAAO;;EACzC;EAAe,OAAO;;EAExB;EACA,QAAQ;;EAER,cAAc"}

package/dist/stream/idle-timeout.d.ts

@@ -0,0 +1,30 @@
+//#region src/stream/idle-timeout.d.ts
+/**
+ * An idle watchdog for streaming responses.
+ *
+ * The failure this guards against is specific and nasty: a provider accepts the
+ * request, returns 200, sends some or none of the body, and then simply stops
+ * without closing the connection. No error is ever delivered, so a plain
+ * `for await` waits forever and the caller's request hangs with no diagnostic.
+ *
+ * The bound is on IDLE time between chunks, not on total duration, because a
+ * legitimately long generation can take minutes while never being idle.
+ *
+ * @module ai-agent-sdk/core/stream/idle-timeout
+ */
+/**
+ * Wrap an async iterable so that any gap longer than `timeoutMs` between values
+ * fails instead of hanging.
+ *
+ * The timer is armed per pending read and cleared as soon as a value arrives, so
+ * a stream that keeps producing never accumulates timers. On expiry the source
+ * iterator is closed, which is what actually aborts the underlying request.
+ * @param iterable - the source stream.
+ * @param timeoutMs - maximum idle interval; non-finite or non-positive disables the watchdog.
+ * @param onTimeout - builds the error to throw, so callers keep their own taxonomy.
+ * @returns the same values, with an idle bound applied.
+ */
+declare function withIdleTimeout<T>(iterable: AsyncIterable<T>, timeoutMs: number, onTimeout: () => Error, teardownTimeoutMs?: number): AsyncGenerator<T>;
+//#endregion
+export { withIdleTimeout };
+//# sourceMappingURL=idle-timeout.d.ts.map

package/dist/stream/idle-timeout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle-timeout.d.ts","names":[],"sources":["../../src/stream/idle-timeout.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;iBA0BuB,gBAAgB,GACrC,UAAU,cAAc,IACxB,mBACA,iBAAiB,OACjB,6BACC,eAAe"}

package/dist/stream/idle-timeout.js

@@ -0,0 +1,2 @@
+import{waitForSettlement as e}from"../async/settlement.js";async function*t(t,n,r,i=3e4){if(!Number.isFinite(n)||n<=0){yield*t;return}let a=t[Symbol.asyncIterator](),o=!1;try{for(;;){let e,t=new Promise((t,i)=>{e=setTimeout(()=>i(r()),n)}),i;try{i=await Promise.race([a.next(),t])}finally{e!==void 0&&clearTimeout(e),t.catch(()=>{})}if(i.done===!0){o=!0;return}yield i.value}}finally{if(!o){if(!Number.isFinite(i)||i<=0)throw RangeError(`teardownTimeoutMs must be a positive finite number`);let t=a.return?.bind(a);if(t!==void 0){let n=Promise.resolve().then(async()=>{await t()});if(!await e(n,i))throw Error(`stream source ignored cancellation for more than ${i}ms`)}}}}export{t as withIdleTimeout};
+//# sourceMappingURL=idle-timeout.js.map

package/dist/stream/idle-timeout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"idle-timeout.js","names":[],"sources":["../../src/stream/idle-timeout.ts"],"sourcesContent":["/**\n * An idle watchdog for streaming responses.\n *\n * The failure this guards against is specific and nasty: a provider accepts the\n * request, returns 200, sends some or none of the body, and then simply stops\n * without closing the connection. No error is ever delivered, so a plain\n * `for await` waits forever and the caller's request hangs with no diagnostic.\n *\n * The bound is on IDLE time between chunks, not on total duration, because a\n * legitimately long generation can take minutes while never being idle.\n *\n * @module ai-agent-sdk/core/stream/idle-timeout\n */\n\n/**\n * Wrap an async iterable so that any gap longer than `timeoutMs` between values\n * fails instead of hanging.\n *\n * The timer is armed per pending read and cleared as soon as a value arrives, so\n * a stream that keeps producing never accumulates timers. On expiry the source\n * iterator is closed, which is what actually aborts the underlying request.\n * @param iterable - the source stream.\n * @param timeoutMs - maximum idle interval; non-finite or non-positive disables the watchdog.\n * @param onTimeout - builds the error to throw, so callers keep their own taxonomy.\n * @returns the same values, with an idle bound applied.\n */\nexport async function* withIdleTimeout<T>(\n  iterable: AsyncIterable<T>,\n  timeoutMs: number,\n  onTimeout: () => Error,\n  teardownTimeoutMs = 30_000,\n): AsyncGenerator<T> {\n  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {\n    yield* iterable\n    return\n  }\n  const iterator = iterable[Symbol.asyncIterator]()\n  let exhausted = false\n  try {\n    while (true) {\n      let timer: ReturnType<typeof setTimeout> | undefined\n      const expiry = new Promise<never>((_resolve, reject) => {\n        timer = setTimeout(() => reject(onTimeout()), timeoutMs)\n      })\n      let result: IteratorResult<T>\n      try {\n        // Both branches settle: `iterator.next()` on data or source failure, the\n        // timer on silence. Whichever loses the race is discarded, and the timer\n        // is always cleared so a resolved read cannot leave the process alive.\n        result = await Promise.race([iterator.next(), expiry])\n      } finally {\n        if (timer !== undefined) clearTimeout(timer)\n        // The losing `expiry` promise rejects later with nothing awaiting it.\n        // Attach a no-op handler so that rejection is never \"unhandled\".\n        void expiry.catch(() => {})\n      }\n      if (result.done === true) {\n        exhausted = true\n        return\n      }\n      yield result.value\n    }\n  } finally {\n    if (!exhausted) {\n      if (!Number.isFinite(teardownTimeoutMs) || teardownTimeoutMs <= 0) {\n        throw new RangeError('teardownTimeoutMs must be a positive finite number')\n      }\n      const close = iterator.return?.bind(iterator)\n      if (close !== undefined) {\n        const closing = Promise.resolve().then(async () => { await close() })\n        if (!await waitForSettlement(closing, teardownTimeoutMs)) {\n          throw new Error(`stream source ignored cancellation for more than ${teardownTimeoutMs}ms`)\n        }\n      }\n    }\n  }\n}\nimport { waitForSettlement } from '../async/settlement.ts'\n"],"mappings":"2DA0BA,eAAuB,EACrB,EACA,EACA,EACA,EAAoB,IACD,CACnB,GAAI,CAAC,OAAO,SAAS,CAAS,GAAK,GAAa,EAAG,CACjD,MAAO,EACP,MACF,CACA,IAAM,EAAW,EAAS,OAAO,cAAc,CAAC,EAC5C,EAAY,GAChB,GAAI,CACF,OAAa,CACX,IAAI,EACE,EAAS,IAAI,SAAgB,EAAU,IAAW,CACtD,EAAQ,eAAiB,EAAO,EAAU,CAAC,EAAG,CAAS,CACzD,CAAC,EACG,EACJ,GAAI,CAIF,EAAS,MAAM,QAAQ,KAAK,CAAC,EAAS,KAAK,EAAG,CAAM,CAAC,CACvD,QAAU,CACJ,IAAU,IAAA,IAAW,aAAa,CAAK,EAG3C,EAAY,UAAY,CAAC,CAAC,CAC5B,CACA,GAAI,EAAO,OAAS,GAAM,CACxB,EAAY,GACZ,MACF,CACA,MAAM,EAAO,KACf,CACF,QAAU,CACR,GAAI,CAAC,EAAW,CACd,GAAI,CAAC,OAAO,SAAS,CAAiB,GAAK,GAAqB,EAC9D,MAAU,WAAW,oDAAoD,EAE3E,IAAM,EAAQ,EAAS,QAAQ,KAAK,CAAQ,EAC5C,GAAI,IAAU,IAAA,GAAW,CACvB,IAAM,EAAU,QAAQ,QAAQ,CAAC,CAAC,KAAK,SAAY,CAAE,MAAM,EAAM,CAAE,CAAC,EACpE,GAAI,CAAC,MAAM,EAAkB,EAAS,CAAiB,EACrD,MAAU,MAAM,oDAAoD,EAAkB,GAAG,CAE7F,CACF,CACF,CACF"}

package/dist/support-safe/error.d.ts

@@ -0,0 +1,29 @@
+//#region src/support-safe/error.d.ts
+interface UsageCoverageSummary {
+  readonly logicalCalls: number;
+  readonly attempts: number;
+  readonly complete: number;
+  readonly partial: number;
+  readonly estimated: number;
+  readonly missing: number;
+  readonly notApplicable: number;
+  readonly possiblyBilledAttemptsWithoutUsage: number;
+}
+/** Metadata-only error shape safe for default diagnostics and public support artifacts. */
+interface SupportSafeError {
+  readonly code: string;
+  readonly stage: string;
+  readonly message: string;
+  readonly provider?: string;
+  readonly route?: string;
+  readonly origin?: string;
+  readonly status?: number;
+  readonly requestId?: string;
+  readonly retryable?: boolean;
+  readonly dispatchState?: 'not-sent' | 'sent' | 'unknown';
+  readonly usageCoverage: UsageCoverageSummary;
+  readonly possiblyBilledAttemptsWithoutUsage: number;
+}
+//#endregion
+export { SupportSafeError, UsageCoverageSummary };
+//# sourceMappingURL=error.d.ts.map

package/dist/support-safe/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","names":[],"sources":["../../src/support-safe/error.ts"],"mappings":";UAAiB;WACN;WACA;WACA;WACA;WACA;WACA;WACA;WACA;;;UAIM;WACN;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA;WACA,eAAe;WACf"}

package/dist/support-safe/error.js

@@ -0,0 +1,2 @@
+const e=Object.freeze({logicalCalls:0,attempts:0,complete:0,partial:0,estimated:0,missing:0,notApplicable:0,possiblyBilledAttemptsWithoutUsage:0});export{e as NOT_APPLICABLE_USAGE_COVERAGE};
+//# sourceMappingURL=error.js.map

package/dist/support-safe/error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","names":[],"sources":["../../src/support-safe/error.ts"],"sourcesContent":["export interface UsageCoverageSummary {\n  readonly logicalCalls: number\n  readonly attempts: number\n  readonly complete: number\n  readonly partial: number\n  readonly estimated: number\n  readonly missing: number\n  readonly notApplicable: number\n  readonly possiblyBilledAttemptsWithoutUsage: number\n}\n\n/** Metadata-only error shape safe for default diagnostics and public support artifacts. */\nexport interface SupportSafeError {\n  readonly code: string\n  readonly stage: string\n  readonly message: string\n  readonly provider?: string\n  readonly route?: string\n  readonly origin?: string\n  readonly status?: number\n  readonly requestId?: string\n  readonly retryable?: boolean\n  readonly dispatchState?: 'not-sent' | 'sent' | 'unknown'\n  readonly usageCoverage: UsageCoverageSummary\n  readonly possiblyBilledAttemptsWithoutUsage: number\n}\n\nexport const NOT_APPLICABLE_USAGE_COVERAGE: UsageCoverageSummary = Object.freeze({\n  logicalCalls: 0, attempts: 0, complete: 0, partial: 0,\n  estimated: 0, missing: 0, notApplicable: 0,\n  possiblyBilledAttemptsWithoutUsage: 0,\n})\n"],"mappings":"AA2BA,MAAa,EAAsD,OAAO,OAAO,CAC/E,aAAc,EAAG,SAAU,EAAG,SAAU,EAAG,QAAS,EACpD,UAAW,EAAG,QAAS,EAAG,cAAe,EACzC,mCAAoC,CACtC,CAAC"}

package/dist/tools.d.ts

@@ -0,0 +1,15 @@
+import { JsonObject, JsonValue } from "./primitives/json.js";
+import { SdkLogger } from "./logging/types.js";
+import { ToolSchema } from "./contract/tool.js";
+import { ToolCallPosition, ToolDefinition, ToolExecutionMode, ToolExecutionResult, ToolFailure, ToolRunContext, ToolSuccess, defineTool, executionModeOf, renderJsonValue } from "./agent/tool/definition.js";
+import { MemorySpillStoreLimits, SPILL_TOOL_NAME, SpillRecord, SpillSlice, SpillStore, ToolOutputOverflowPolicy, TruncatedText, createMemorySpillStore, estimateTextBlockTokens, estimateTextTokens, previewForSpill, readSpillTool, truncateMiddleToTokens } from "./agent/tool/output-budget.js";
+import { ApprovalBroker, ApprovalDecision, ApprovalRequest, ApprovalStateStore, InteractiveApprovalBroker, InteractiveApprovalBrokerOptions, createApprovalBroker, createApprovalRequest, fixedApprovalBroker, withApprovalPersistence } from "./agent/tool/approval.js";
+import { REGISTRY_ERROR_CODES, ToolCatalog, ToolFilter, ToolRegistry } from "./agent/tool/registry.js";
+import { AuthorizationOutcome, AuthorizedToolCall, DispatchToolCallOptions, PostToolDecision, PreToolDecision, PreparedToolCall, ToolCallContext, ToolCallRequest, ToolInterceptor, authorizeToolCall, dispatchAuthorizedToolCall, dispatchToolCall, finalizeToolCall, prepareToolCall, toolFailure } from "./agent/tool/pipeline.js";
+import { ToolCatalogSnapshot, ToolSource, ToolSourceDefinition, ToolSourceRunReference, ToolSourceSnapshotOptions } from "./agent/tool/source-types.js";
+import { TOOL_ERROR_CODES, ToolError, ToolErrorDisposition, toolErrorDisposition } from "./agent/tool/errors.js";
+import { RuntimeSchema, defineToolFromSchema } from "./agent/tool/schema.js";
+import { ToolExecutionBackend, ToolExecutionCapabilities, ToolExecutionRequest, ToolExecutionStore, ToolOperation, ToolOperationClaim, createToolExecutionInterceptor, localToolExecutionBackend } from "./agent/tool/execution.js";
+import { TOOL_SOURCE_API_VERSION } from "./composition/tool-source/config.js";
+import { defineToolSource } from "./composition/tool-source/definition.js";
+export { type ApprovalBroker, type ApprovalDecision, type ApprovalRequest, type ApprovalStateStore, type AuthorizationOutcome, type AuthorizedToolCall, type DispatchToolCallOptions, type InteractiveApprovalBroker, type InteractiveApprovalBrokerOptions, type JsonObject, type JsonValue, type MemorySpillStoreLimits, type PostToolDecision, type PreToolDecision, type PreparedToolCall, type RuntimeSchema, SPILL_TOOL_NAME, type SdkLogger, type SpillRecord, type SpillSlice, type SpillStore, TOOL_ERROR_CODES, REGISTRY_ERROR_CODES as TOOL_REGISTRY_ERROR_CODES, TOOL_SOURCE_API_VERSION, type ToolCallContext, type ToolCallPosition, type ToolCallRequest, type ToolCatalog, type ToolCatalogSnapshot, type ToolDefinition, ToolError, type ToolErrorDisposition, type ToolExecutionBackend, type ToolExecutionCapabilities, type ToolExecutionMode, type ToolExecutionRequest, type ToolExecutionResult, type ToolExecutionStore, type ToolFailure, type ToolFilter, type ToolInterceptor, type ToolOperation, type ToolOperationClaim, type ToolOutputOverflowPolicy, ToolRegistry, type ToolRunContext, type ToolSchema, type ToolSource, type ToolSourceDefinition, type ToolSourceRunReference, type ToolSourceSnapshotOptions, type ToolSuccess, type TruncatedText, authorizeToolCall, createApprovalBroker, createApprovalRequest, createMemorySpillStore, createToolExecutionInterceptor, defineTool, defineToolFromSchema, defineToolSource, dispatchAuthorizedToolCall, dispatchToolCall, estimateTextBlockTokens, estimateTextTokens, executionModeOf, finalizeToolCall, fixedApprovalBroker, localToolExecutionBackend, prepareToolCall, previewForSpill, readSpillTool, renderJsonValue, toolErrorDisposition, toolFailure, truncateMiddleToTokens, withApprovalPersistence };

package/dist/tools.js

@@ -0,0 +1 @@
+import{defineTool as e,executionModeOf as t,renderJsonValue as n}from"./agent/tool/definition.js";import{REGISTRY_ERROR_CODES as r,ToolRegistry as i}from"./agent/tool/registry.js";import{SPILL_TOOL_NAME as a,createMemorySpillStore as o,estimateTextBlockTokens as s,estimateTextTokens as c,previewForSpill as l,readSpillTool as u,truncateMiddleToTokens as d}from"./agent/tool/output-budget.js";import{TOOL_ERROR_CODES as f,ToolError as p,toolErrorDisposition as m}from"./agent/tool/errors.js";import{createApprovalBroker as h,createApprovalRequest as g,fixedApprovalBroker as _,withApprovalPersistence as v}from"./agent/tool/approval.js";import{authorizeToolCall as y,dispatchAuthorizedToolCall as b,dispatchToolCall as x,finalizeToolCall as S,prepareToolCall as C,toolFailure as w}from"./agent/tool/pipeline.js";import{TOOL_SOURCE_API_VERSION as T}from"./composition/tool-source/config.js";import{defineToolSource as E}from"./composition/tool-source/definition.js";import{defineToolFromSchema as D}from"./agent/tool/schema.js";import{createToolExecutionInterceptor as O,localToolExecutionBackend as k}from"./agent/tool/execution.js";export{a as SPILL_TOOL_NAME,f as TOOL_ERROR_CODES,r as TOOL_REGISTRY_ERROR_CODES,T as TOOL_SOURCE_API_VERSION,p as ToolError,i as ToolRegistry,y as authorizeToolCall,h as createApprovalBroker,g as createApprovalRequest,o as createMemorySpillStore,O as createToolExecutionInterceptor,e as defineTool,D as defineToolFromSchema,E as defineToolSource,b as dispatchAuthorizedToolCall,x as dispatchToolCall,s as estimateTextBlockTokens,c as estimateTextTokens,t as executionModeOf,S as finalizeToolCall,_ as fixedApprovalBroker,k as localToolExecutionBackend,C as prepareToolCall,l as previewForSpill,u as readSpillTool,n as renderJsonValue,m as toolErrorDisposition,w as toolFailure,d as truncateMiddleToTokens,v as withApprovalPersistence};