@agentproto/adapter-ai-sdk 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jeremy André and agentproto contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { Tool } from 'ai';
+import { ToolContext } from '@agentproto/tool';
+import { DriverContext, ToolImplementation } from '@agentproto/driver';
+export { ToolImplementation } from '@agentproto/driver';
+
+/**
+ * @agentproto/adapter-ai-sdk — AI SDK adapter for AIP-30
+ * `ToolImplementation`s.
+ *
+ * One function: {@link toAiSdkTool} takes a typed `ToolImplementation`
+ * (an `(contract, body)` pair produced by
+ * {@link "@agentproto/driver".implementTool}) and returns an AI SDK
+ * `Tool` that drops into `streamText({ tools })`, `generateText`, or
+ * any downstream consumer that speaks the AI SDK tool surface (Mastra
+ * wraps it, LangChain has interop, …).
+ *
+ * Same shape and semantics as `@agentproto/adapter-mastra` so apps
+ * authoring tools once via `defineTool` + `implementTool` can ship
+ * to either runtime — or both — without re-writing the body.
+ *
+ * Spec: https://agentproto.sh/docs/aip-14, https://agentproto.sh/docs/aip-30
+ */
+
+interface ToAiSdkToolOptions<TContext extends ToolContext> {
+    /** Per-request context passed through to the body's `context` arg. */
+    context: TContext;
+    /**
+     * Optional provider context — typically only needed for non-builtin
+     * adapters that read `driverCtx.secrets` or `driverCtx.region`.
+     * Builtin bodies usually leave this defaulted.
+     */
+    driverCtx?: DriverContext;
+}
+/**
+ * Adapt a {@link ToolImplementation} into an AI SDK v5 `Tool`.
+ *
+ * Type inference: `TContext` is inferred from `impl` only —
+ * `bind.context` is wrapped in `NoInfer<>` so a literal like
+ * `{ locale: "en" }` doesn't narrow the contract's
+ * `{ locale: "en" | "fr" }` and reject the impl via TS's
+ * contravariant-position function check.
+ *
+ * Implementation note: we dispatch through `dynamicTool` rather than
+ * the typed `tool` overloads. The static `Tool<INPUT, OUTPUT>` type
+ * uses a `NeverOptional<OUTPUT, …>` conditional that TS can't
+ * evaluate through generic type parameters — the structural
+ * assignment fails at the overload-resolution level even though the
+ * shape is valid. `dynamicTool` accepts `FlexibleSchema<unknown>` +
+ * `ToolExecuteFn<unknown, unknown>` directly (no NeverOptional gate),
+ * runs the same identity adapter at runtime, and returns a marked
+ * Tool that AI SDK's streamText / generateText accept everywhere.
+ * Schema-level validation is preserved because we pass the contract's
+ * Zod inputSchema through unchanged.
+ */
+declare function toAiSdkTool<TInput, TOutput, TContext extends ToolContext>(impl: ToolImplementation<TInput, TOutput, TContext>, bind: ToAiSdkToolOptions<NoInfer<TContext>>): Tool<unknown, unknown> & {
+    type: "dynamic";
+};
+
+export { type ToAiSdkToolOptions, toAiSdkTool };

package/dist/index.mjs

@@ -0,0 +1,35 @@
+import { dynamicTool } from 'ai';
+
+/**
+ * @agentproto/adapter-ai-sdk v0.1.0-alpha
+ * AI SDK adapter for AIP-30 ToolImplementations.
+ */
+
+var DEFAULT_PROVIDER_CTX = Object.freeze({
+  secrets: {},
+  authState: "authed",
+  providerId: "ai-sdk-adapter",
+  driverKind: "builtin",
+  implementsEntry: { tool: "ai-sdk-adapter", version: "0.0.0" }
+});
+function toAiSdkTool(impl, bind) {
+  return dynamicTool({
+    description: impl.tool.description,
+    // AI SDK v5 uses `inputSchema` and accepts Zod schemas natively
+    // via `FlexibleSchema<unknown>`; our Zod handle widens cleanly.
+    inputSchema: impl.tool.inputSchema,
+    execute: async (input, options) => {
+      const typedInput = input;
+      return impl.body({
+        input: typedInput,
+        context: bind.context,
+        driverCtx: bind.driverCtx ?? DEFAULT_PROVIDER_CTX,
+        signal: options.abortSignal ?? new AbortController().signal
+      });
+    }
+  });
+}
+
+export { toAiSdkTool };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;AAgCA,IAAM,oBAAA,GAAsC,OAAO,MAAA,CAAO;AAAA,EACxD,SAAS,EAAC;AAAA,EACV,SAAA,EAAW,QAAA;AAAA,EACX,UAAA,EAAY,gBAAA;AAAA,EACZ,UAAA,EAAY,SAAA;AAAA,EACZ,eAAA,EAAiB,EAAE,IAAA,EAAM,gBAAA,EAAkB,SAAS,OAAA;AACtD,CAAC,CAAA;AAkCM,SAAS,WAAA,CACd,MACA,IAAA,EACgD;AAChD,EAAA,OAAO,WAAA,CAAY;AAAA,IACjB,WAAA,EAAa,KAAK,IAAA,CAAK,WAAA;AAAA;AAAA;AAAA,IAGvB,WAAA,EAAa,KAAK,IAAA,CAAK,WAAA;AAAA,IACvB,OAAA,EAAS,OAAO,KAAA,EAAgB,OAAA,KAA6B;AAQ3D,MAAA,MAAM,UAAA,GAAqB,KAAA;AAC3B,MAAA,OAAO,KAAK,IAAA,CAAK;AAAA,QACf,KAAA,EAAO,UAAA;AAAA,QACP,SAAS,IAAA,CAAK,OAAA;AAAA,QACd,SAAA,EAAW,KAAK,SAAA,IAAa,oBAAA;AAAA,QAC7B,MAAA,EAAQ,OAAA,CAAQ,WAAA,IAAe,IAAI,iBAAgB,CAAE;AAAA,OACtD,CAAA;AAAA,IACH;AAAA,GACD,CAAA;AACH","file":"index.mjs","sourcesContent":["/**\n * @agentproto/adapter-ai-sdk — AI SDK adapter for AIP-30\n * `ToolImplementation`s.\n *\n * One function: {@link toAiSdkTool} takes a typed `ToolImplementation`\n * (an `(contract, body)` pair produced by\n * {@link \"@agentproto/driver\".implementTool}) and returns an AI SDK\n * `Tool` that drops into `streamText({ tools })`, `generateText`, or\n * any downstream consumer that speaks the AI SDK tool surface (Mastra\n * wraps it, LangChain has interop, …).\n *\n * Same shape and semantics as `@agentproto/adapter-mastra` so apps\n * authoring tools once via `defineTool` + `implementTool` can ship\n * to either runtime — or both — without re-writing the body.\n *\n * Spec: https://agentproto.sh/docs/aip-14, https://agentproto.sh/docs/aip-30\n */\n\nimport { dynamicTool } from \"ai\"\nimport type { Tool as AiTool, ToolCallOptions } from \"ai\"\nimport type { ToolContext } from \"@agentproto/tool\"\nimport type {\n  DriverContext,\n  ToolImplementation,\n} from \"@agentproto/driver\"\n\n/**\n * Default {@link DriverContext} used when the caller doesn't pass\n * one. `kind: \"builtin\"` reflects the typical adapter use-case\n * (in-process bodies that don't read provider secrets / sandbox\n * handles). Override via `bind.driverCtx` for non-builtin bodies.\n */\nconst DEFAULT_PROVIDER_CTX: DriverContext = Object.freeze({\n  secrets: {},\n  authState: \"authed\",\n  providerId: \"ai-sdk-adapter\",\n  driverKind: \"builtin\",\n  implementsEntry: { tool: \"ai-sdk-adapter\", version: \"0.0.0\" },\n})\n\nexport interface ToAiSdkToolOptions<TContext extends ToolContext> {\n  /** Per-request context passed through to the body's `context` arg. */\n  context: TContext\n  /**\n   * Optional provider context — typically only needed for non-builtin\n   * adapters that read `driverCtx.secrets` or `driverCtx.region`.\n   * Builtin bodies usually leave this defaulted.\n   */\n  driverCtx?: DriverContext\n}\n\n/**\n * Adapt a {@link ToolImplementation} into an AI SDK v5 `Tool`.\n *\n * Type inference: `TContext` is inferred from `impl` only —\n * `bind.context` is wrapped in `NoInfer<>` so a literal like\n * `{ locale: \"en\" }` doesn't narrow the contract's\n * `{ locale: \"en\" | \"fr\" }` and reject the impl via TS's\n * contravariant-position function check.\n *\n * Implementation note: we dispatch through `dynamicTool` rather than\n * the typed `tool` overloads. The static `Tool<INPUT, OUTPUT>` type\n * uses a `NeverOptional<OUTPUT, …>` conditional that TS can't\n * evaluate through generic type parameters — the structural\n * assignment fails at the overload-resolution level even though the\n * shape is valid. `dynamicTool` accepts `FlexibleSchema<unknown>` +\n * `ToolExecuteFn<unknown, unknown>` directly (no NeverOptional gate),\n * runs the same identity adapter at runtime, and returns a marked\n * Tool that AI SDK's streamText / generateText accept everywhere.\n * Schema-level validation is preserved because we pass the contract's\n * Zod inputSchema through unchanged.\n */\nexport function toAiSdkTool<TInput, TOutput, TContext extends ToolContext>(\n  impl: ToolImplementation<TInput, TOutput, TContext>,\n  bind: ToAiSdkToolOptions<NoInfer<TContext>>\n): AiTool<unknown, unknown> & { type: \"dynamic\" } {\n  return dynamicTool({\n    description: impl.tool.description,\n    // AI SDK v5 uses `inputSchema` and accepts Zod schemas natively\n    // via `FlexibleSchema<unknown>`; our Zod handle widens cleanly.\n    inputSchema: impl.tool.inputSchema,\n    execute: async (input: unknown, options: ToolCallOptions) => {\n      // AI SDK validates `input` against `inputSchema` BEFORE calling\n      // execute (per its docs and verified in `@ai-sdk/provider-\n      // utils@3.0.20` source). At this point `input` is structurally\n      // `TInput`; TS's `unknown` here reflects only the dynamicTool\n      // signature, not the runtime contract. Narrowing via a noop\n      // assignment to a TInput-typed variable expresses the post-\n      // validation type without adding a runtime parse.\n      const typedInput: TInput = input as TInput\n      return impl.body({\n        input: typedInput,\n        context: bind.context,\n        driverCtx: bind.driverCtx ?? DEFAULT_PROVIDER_CTX,\n        signal: options.abortSignal ?? new AbortController().signal,\n      })\n    },\n  })\n}\n\nexport type { ToolImplementation } from \"@agentproto/driver\"\n"]}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@agentproto/adapter-ai-sdk",
+  "version": "0.1.1",
+  "description": "AI SDK adapter for AIP-30 ToolImplementations. Wraps any `@agentproto/driver` ToolImplementation into a Vercel AI SDK Tool ready to drop into `streamText({ tools })`, `generateText`, or any downstream consumer that speaks the AI SDK tool surface.",
+  "keywords": [
+    "agentproto",
+    "aip-30",
+    "ai-sdk",
+    "vercel-ai",
+    "tool",
+    "adapter",
+    "open-standard"
+  ],
+  "homepage": "https://agentproto.sh/docs/aip-30",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/agentproto/ts"
+  },
+  "bugs": {
+    "url": "https://github.com/agentproto/ts/issues"
+  },
+  "license": "MIT",
+  "type": "module",
+  "main": "dist/index.mjs",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@agentproto/driver": "0.1.1",
+    "@agentproto/tool": "0.1.1"
+  },
+  "peerDependencies": {
+    "ai": "^5.0.0 || ^6.0.0",
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.6.2",
+    "ai": "^6.0.204",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.4",
+    "zod": "^4.4.3",
+    "@agentproto/tooling": "0.1.0-alpha.0"
+  },
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "check-types": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}