@opencode/core 0.0.0-dev-19587 → 0.0.0-dev-19588

package/dist/chunks/{aisdk-native-1sk4t3bw.js → repository-q9fqv6nm.js}

@@ -1,70 +1,61 @@
 import {
   makeUnsafe2
-} from "./aisdk-native-y71avatq.js";
+} from "./repository-y71avatq.js";
 import {
-  Service79,
-  node84
-} from "./aisdk-native-hceg7q13.js";
+  Service78,
+  node83
+} from "./repository-cpn39njb.js";
 import {
-  Event18,
-  Service67,
-  node71
-} from "./aisdk-native-732en32p.js";
+  Event19,
+  Service75,
+  node79
+} from "./repository-1vnsgk5t.js";
 import {
-  Service73,
-  node78
-} from "./aisdk-native-v9kk4whf.js";
+  Service66,
+  node70
+} from "./repository-1e17p1v6.js";
 import {
-  Service71,
-  node75
-} from "./aisdk-native-73rvebw6.js";
+  Service65,
+  node69
+} from "./repository-5dwnc6b3.js";
 import {
-  ID14,
-  Service68,
-  node72
-} from "./aisdk-native-5tc8t3sp.js";
+  ID18,
+  Service77,
+  node82
+} from "./repository-y5znnrem.js";
 import {
   reconcile2,
   create3
-} from "./aisdk-native-kg06axw8.js";
+} from "./repository-kg06axw8.js";
 import {
-  ID11,
+  ID13,
   MethodID2,
-  Service66,
-  node70
-} from "./aisdk-native-1hstdxwt.js";
+  Service74,
+  node78
+} from "./repository-b3pcj4k8.js";
 import {
   __export
-} from "./aisdk-native-9rqn6x4v.js";
+} from "./repository-9rqn6x4v.js";
 
 // src/mcp/index.ts
 var exports_mcp4 = {};
 __export(exports_mcp4, {
   Mcp: () => exports_mcp4,
-  NotFoundError: () => NotFoundError4,
-  Options: () => Options3,
-  Prompt: () => Prompt2,
-  PromptArgument: () => PromptArgument2,
-  PromptMessage: () => PromptMessage2,
-  PromptResult: () => PromptResult2,
+  NotFoundError: () => NotFoundError5,
+  Options: () => Options5,
   PromptsChanged: () => PromptsChanged2,
   Resource: () => Resource2,
   ResourceCatalog: () => ResourceCatalog2,
   ResourceContent: () => ResourceContent2,
   ResourceContentPart: () => ResourceContentPart2,
   ResourceTemplate: () => ResourceTemplate2,
-  ServerInfo: () => ServerInfo2,
-  ServerInstructions: () => ServerInstructions2,
   ServerName: () => ServerName2,
   Service: () => Service31,
   Status: () => Status2,
-  Tool: () => Tool3,
   ToolCallError: () => ToolCallError2,
-  ToolResult: () => ToolResult2,
-  ToolResultContent: () => ToolResultContent2,
-  configured: () => configured3,
+  configured: () => configured5,
   layer: () => layer13,
-  node: () => node35
+  node: () => node36
 });
 import { Mcp } from "@opencode/schema/mcp";
 import { McpEvent } from "@opencode/schema/mcp-event";
@@ -77,77 +68,13 @@ import { waitForAbort } from "@opencode/util/process";
 var ServerName2 = Schema.String.pipe(Schema.brand("MCP.ServerName"));
 var PromptsChanged2 = ephemeral({ type: "mcp.prompts.changed", schema: { server: Schema.String } });
 var Status2 = Mcp.Status;
-
-class ServerInfo2 extends Schema.Class("MCP.ServerInfo")({
-  name: ServerName2,
-  status: Status2,
-  integrationID: ID11.pipe(Schema.optional)
-}) {
-}
-
-class ServerInstructions2 extends Schema.Class("MCP.ServerInstructions")({
-  server: ServerName2,
-  instructions: Schema.String
-}) {
-}
-
-class Tool3 extends Schema.Class("MCP.Tool")({
-  server: ServerName2,
-  name: Schema.String,
-  codemode: Schema.Boolean.pipe(Schema.optional),
-  description: Schema.String.pipe(Schema.optional),
-  inputSchema: Schema.Unknown.pipe(Schema.optional),
-  outputSchema: Schema.Unknown.pipe(Schema.optional)
-}) {
-}
-var ToolResultContent2 = Schema.Union([
-  Schema.Struct({ type: Schema.Literal("text"), text: Schema.String }),
-  Schema.Struct({ type: Schema.Literal("media"), data: Schema.String, mimeType: Schema.String })
-]).pipe(Schema.toTaggedUnion("type"));
-
-class ToolResult2 extends Schema.Class("MCP.ToolResult")({
-  server: ServerName2,
-  tool: Schema.String,
-  isError: Schema.Boolean,
-  structured: Schema.Unknown.pipe(Schema.optional),
-  content: Schema.Array(ToolResultContent2)
-}) {
-}
-
-class PromptArgument2 extends Schema.Class("MCP.PromptArgument")({
-  name: Schema.String,
-  description: Schema.String.pipe(Schema.optional),
-  required: Schema.Boolean.pipe(Schema.optional)
-}) {
-}
-
-class Prompt2 extends Schema.Class("MCP.Prompt")({
-  server: ServerName2,
-  name: Schema.String,
-  description: Schema.String.pipe(Schema.optional),
-  arguments: Schema.Array(PromptArgument2).pipe(Schema.optional)
-}) {
-}
-
-class PromptMessage2 extends Schema.Class("MCP.PromptMessage")({
-  role: Schema.String,
-  content: Schema.Unknown
-}) {
-}
-
-class PromptResult2 extends Schema.Class("MCP.PromptResult")({
-  server: ServerName2,
-  name: Schema.String,
-  messages: Schema.Array(PromptMessage2)
-}) {
-}
 var Resource2 = Mcp.Resource;
 var ResourceTemplate2 = Mcp.ResourceTemplate;
 var ResourceCatalog2 = Mcp.ResourceCatalog;
 var ResourceContentPart2 = Mcp.ResourceContentPart;
 var ResourceContent2 = Mcp.ResourceContent;
 
-class NotFoundError4 extends Schema.TaggedError()("MCP.NotFoundError", {
+class NotFoundError5 extends Schema.TaggedError()("MCP.NotFoundError", {
   server: ServerName2
 }) {
   get message() {
@@ -167,19 +94,19 @@ var cloneConfig = (config) => structuredClone(config);
 
 class Service31 extends Context.Service()("@opencode/MCP") {
 }
-var Options3 = Schema.Struct({
+var Options5 = Schema.Struct({
   clientInfo: Schema.optional(Schema.Struct({
     name: Schema.String,
     version: Schema.String
   }))
 });
 var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
-  const location = yield* Service73;
-  const environment = yield* Service71;
-  const bus = yield* Service79;
-  const forms = yield* Service68;
-  const integration = yield* Service66;
-  const credentials = yield* Service67;
+  const location = yield* Service66;
+  const environment = yield* Service65;
+  const bus = yield* Service78;
+  const forms = yield* Service77;
+  const integration = yield* Service74;
+  const credentials = yield* Service75;
   const root = yield* Effect.scope;
   const fork = yield* FiberSet.makeRuntime();
   const entries = new Map;
@@ -191,7 +118,7 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       return;
     const remote = entry.config;
     const suffix = "mcp_" + createHash("sha1").update(name + "\x00" + remote.url).digest("hex").slice(0, 16);
-    const integrationID = ID11.make(suffix);
+    const integrationID = ID13.make(suffix);
     entry.integrationID = integrationID;
     owned.add(integrationID);
     const methodID = MethodID2.make(suffix);
@@ -207,7 +134,7 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
         method: { id: methodID, type: "oauth", label: name },
         authorize: () => Effect.gen(function* () {
           const { McpOAuth } = yield* Effect.promise(() => import("../mcp/oauth.js"));
-          return yield* McpOAuth.authorize({ name, config: remote, methodID });
+          return yield* McpOAuth.authorize({ name, config: remote, integrationID, methodID }).pipe(Effect.provideService(Service75, credentials));
         })
       });
     }).pipe(Scope.provide(scope));
@@ -216,108 +143,23 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
     const name = ServerName2.make(server);
     const entry = entries.get(name);
     if (!entry)
-      return yield* new NotFoundError4({ server: name });
+      return yield* new NotFoundError5({ server: name });
     return { name, entry };
   });
   const connectProvider = Effect.fnUntraced(function* (entry) {
     if (entry.config.type !== "remote" || !entry.integrationID)
       return;
     const { McpOAuth } = yield* Effect.promise(() => import("../mcp/oauth.js"));
-    const remote = entry.config;
-    const oauth = remote.oauth || undefined;
-    const run = Effect.runPromiseWith(yield* Effect.context());
-    const base = {
-      redirectUrl: oauth?.redirect_uri ?? "http://127.0.0.1/callback",
-      scope: oauth?.scope,
-      client: oauth?.client_id ? { id: oauth.client_id, secret: oauth.client_secret } : undefined,
-      onRedirect: () => run(Effect.logInfo("mcp oauth authorization required"))
-    };
-    const found = (yield* credentials.list(entry.integrationID)).at(-1);
-    if (!found || found.value.type !== "oauth") {
-      yield* Effect.logInfo("mcp oauth credential unavailable", {
-        integrationID: entry.integrationID,
-        reason: found ? "not_oauth" : "missing"
-      });
-      return McpOAuth.provider({ ...base, store: McpOAuth.memoryStore() });
-    }
-    const credentialID = found.id;
-    const methodID = found.value.methodID;
-    const fields = { credentialID, integrationID: entry.integrationID };
-    yield* Effect.logInfo("mcp oauth credential loaded", {
-      ...fields,
-      hasRefreshToken: Boolean(found.value.refresh),
-      hasClientInformation: Boolean(McpOAuth.clientFromCredential(found.value)),
-      expiresAt: found.value.expires,
-      expired: found.value.expires !== 0 && found.value.expires <= Date.now()
-    });
-    let presented = found.value.refresh;
-    const readOAuthCredential = async () => {
-      const stored = await run(credentials.get(credentialID));
-      return stored?.value.type === "oauth" ? stored.value : undefined;
-    };
-    return McpOAuth.provider({
-      ...base,
-      invalidate: async (scope) => {
-        if (scope === "verifier" || scope === "discovery") {
-          await run(Effect.logDebug("mcp oauth invalidation skipped", { ...fields, scope, reason: "not_credentials" }));
-          return;
-        }
-        const oauth = await readOAuthCredential();
-        if (!oauth || oauth.refresh !== presented) {
-          await run(Effect.logInfo("mcp oauth invalidation skipped", {
-            ...fields,
-            scope,
-            reason: oauth ? "token_rotated" : "credential_missing"
-          }));
-          return;
-        }
-        await run(Effect.logWarning("mcp oauth credential invalidation requested", { ...fields, scope }));
-        await run(credentials.remove(credentialID));
-      },
-      store: {
-        tokens: async () => {
-          const oauth = await readOAuthCredential();
-          if (!oauth)
-            return;
-          presented = oauth.refresh;
-          return McpOAuth.toTokens(oauth);
-        },
-        saveTokens: async (tokens) => {
-          const previous = await readOAuthCredential();
-          const value = McpOAuth.toCredential({
-            methodID,
-            serverUrl: remote.url,
-            tokens,
-            client: previous ? McpOAuth.clientFromCredential(previous) : undefined
-          });
-          presented = value.refresh;
-          await run(Effect.logInfo("mcp oauth tokens received", {
-            ...fields,
-            credentialPresent: Boolean(previous),
-            refreshRotated: Boolean(previous && previous.refresh !== value.refresh),
-            hasRefreshToken: Boolean(value.refresh),
-            expiresAt: value.expires
-          }));
-          await run(credentials.update(credentialID, { value }));
-        },
-        clientInformation: async () => {
-          const oauth = await readOAuthCredential();
-          return oauth ? McpOAuth.clientFromCredential(oauth) : undefined;
-        },
-        saveClientInformation: async () => {},
-        codeVerifier: async () => {
-          return;
-        },
-        saveCodeVerifier: async () => {}
-      }
-    });
+    return yield* McpOAuth.connectProvider({ config: entry.config, integrationID: entry.integrationID }).pipe(Effect.provideService(Service75, credentials));
   });
   const elicitation = {
     create: (input) => Effect.gen(function* () {
       if (input.params.mode === "url") {
-        const formID = ID14.create();
-        const key = input.server + "\x00" + input.params.elicitationId;
-        urlElicitations.set(key, formID);
+        const formID = ID18.create();
+        const elicitationID = input.params.elicitationId;
+        const key = elicitationID === undefined ? undefined : input.server + "\x00" + elicitationID;
+        if (key)
+          urlElicitations.set(key, formID);
         return yield* forms.ask({
           id: formID,
           sessionID: GLOBAL_ELICITATION_SESSION_ID,
@@ -325,11 +167,11 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
           metadata: {
             kind: "mcp-elicitation",
             server: input.server,
-            elicitationID: input.params.elicitationId,
+            ...elicitationID === undefined ? {} : { elicitationID },
             message: input.params.message
           },
           fields: [{ key: URL_ELICITATION_FIELD_KEY, type: "external", url: input.params.url }]
-        }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.ensuring(Effect.sync(() => urlElicitations.delete(key))), Effect.map((state) => ({
+        }).pipe(Effect.raceFirst(waitForAbort(input.signal)), Effect.ensuring(Effect.sync(() => key && urlElicitations.delete(key))), Effect.map((state) => ({
           action: state.status === "answered" ? "accept" : "cancel"
         })));
       }
@@ -358,45 +200,26 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       yield* forms.reply({ id: formID, answer: { [URL_ELICITATION_FIELD_KEY]: true } }).pipe(Effect.ignore);
     })
   };
-  const toTool = (server, entry, def) => new Tool3({
+  const toTool = (server, entry, tool) => ({
+    ...tool,
     server,
-    name: def.name,
-    codemode: entry.config.codemode,
-    description: def.description,
-    inputSchema: def.inputSchema,
-    outputSchema: def.outputSchema
+    ...entry.config.codemode === undefined ? {} : { codemode: entry.config.codemode }
   });
-  const toPrompt = (server, def) => new Prompt2({
-    server,
-    name: def.name,
-    description: def.description,
-    arguments: def.arguments?.map((argument) => new PromptArgument2({
-      name: argument.name,
-      description: argument.description,
-      required: argument.required
-    }))
-  });
-  const toResource = (server, def) => Resource2.make({
-    server,
-    name: def.name,
-    uri: def.uri,
-    description: def.description,
-    mimeType: def.mimeType
-  });
-  const toResourceTemplate = (server, def) => ResourceTemplate2.make({
-    server,
-    name: def.name,
-    uriTemplate: def.uriTemplate,
-    description: def.description,
-    mimeType: def.mimeType
-  });
-  const refreshTools = (name, entry, connection) => connection.tools().pipe(Effect.map((defs) => {
-    entry.tools = defs.map((def) => toTool(name, entry, def));
+  const refreshTools = (name, entry, connection) => connection.tools().pipe(Effect.map((tools) => {
+    entry.tools = tools.map((tool) => toTool(name, entry, tool));
   }));
-  const refreshPrompts = (name, entry, connection) => connection.prompts().pipe(Effect.orElseSucceed(() => []), Effect.map((defs) => {
-    entry.prompts = defs.map((def) => toPrompt(name, def));
+  const refreshPrompts = (name, entry, connection) => connection.prompts().pipe(Effect.orElseSucceed(() => []), Effect.map((prompts) => {
+    entry.prompts = prompts.map((prompt) => ({ ...prompt, server: name }));
   }), Effect.andThen(bus.publish(PromptsChanged2, { server: name })));
   const whenLive = (name, entry, connection) => (effect) => fork(Effect.suspend(() => entry.client === connection ? effect : Effect.void).pipe(locks.withLock(name), Effect.ignore));
+  const recover = (name, entry, connection) => Effect.gen(function* () {
+    if (entry.client !== connection)
+      return;
+    yield* Effect.logInfo("mcp session expired, reconnecting", { server: name });
+    yield* stopServer(name, entry);
+    yield* startServer(name, entry);
+  }).pipe(locks.withLock(name));
+  const recovering = (name, entry, connection, run) => run(connection).pipe(Effect.catchIf((error) => ("_tag" in error) && error._tag === "MCP.SessionExpiredError", (error) => recover(name, entry, connection).pipe(Effect.flatMap(() => entry.client ? run(entry.client) : Effect.fail(error)))));
   const watch = (name, entry, connection) => {
     const live = whenLive(name, entry, connection);
     connection.onClose(() => live(Effect.gen(function* () {
@@ -404,28 +227,11 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       yield* stopServer(name, entry);
       yield* bus.publish(McpEvent.StatusChanged, { server: name });
     })));
-    connection.onLog((message) => fork(serverLog(name, message)));
+    connection.onSessionExpired(() => fork(recover(name, entry, connection)));
     connection.onToolsChanged(() => live(refreshTools(name, entry, connection).pipe(Effect.andThen(bus.publish(McpEvent.ToolsChanged, { server: name })))));
     connection.onPromptsChanged(() => live(refreshPrompts(name, entry, connection)));
     connection.onResourcesChanged(() => live(bus.publish(McpEvent.ResourcesChanged, { server: name })));
   };
-  const serverLog = (server, message) => {
-    const fields = { server, logger: message.logger, level: message.level, data: message.data };
-    switch (message.level) {
-      case "debug":
-        return Effect.logDebug("MCP server log", fields);
-      case "info":
-      case "notice":
-        return Effect.logInfo("MCP server log", fields);
-      case "warning":
-        return Effect.logWarning("MCP server log", fields);
-      case "error":
-      case "critical":
-      case "alert":
-      case "emergency":
-        return Effect.logError("MCP server log", fields);
-    }
-  };
   const startServer = (name, entry) => Effect.gen(function* () {
     entry.status = { status: "pending" };
     yield* bus.publish(McpEvent.StatusChanged, { server: name });
@@ -433,10 +239,10 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
     entry.scope = scope;
     const authProvider = yield* connectProvider(entry);
     const { McpClient } = yield* Effect.promise(() => import("../mcp/client.js"));
-    const result = yield* McpClient.connect(name, entry.config, location.directory, authProvider, elicitation, options?.clientInfo).pipe(Effect.flatMap((connection) => connection.tools().pipe(Effect.map((tools) => ({ connection, tools })))), Effect.provideService(Service71, environment), Scope.provide(scope), Effect.exit);
+    const result = yield* McpClient.connect(name, entry.config, location.directory, authProvider, elicitation, options?.clientInfo).pipe(Effect.flatMap((connection) => connection.tools().pipe(Effect.map((tools) => ({ connection, tools })))), Effect.provideService(Service65, environment), Scope.provide(scope), Effect.exit);
     if (Exit.isSuccess(result)) {
       entry.client = result.value.connection;
-      entry.tools = result.value.tools.map((def) => toTool(name, entry, def));
+      entry.tools = result.value.tools.map((tool) => toTool(name, entry, tool));
       entry.prompts = [];
       entry.status = { status: "connected" };
       watch(name, entry, result.value.connection);
@@ -557,7 +363,7 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       yield* startServer(name, entry);
     }).pipe(locks.withLock(name));
   });
-  fork(bus.subscribe(Event18.Switched).pipe(Stream.filter((event) => owned.has(event.data.integrationID)), Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID))))));
+  fork(bus.subscribe(Event19.Switched).pipe(Stream.filter((event) => owned.has(event.data.integrationID)), Stream.runForEach((event) => Effect.sync(() => fork(reconnect(event.data.integrationID))))));
   const state = create3({
     name: "mcp",
     initial: () => ({
@@ -583,15 +389,11 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
     }),
     notify: () => reconcile2(root, fork, () => reconcileLock.withPermit(reconcile()))
   });
-  const whenAllReady = Effect.suspend(() => Effect.forEach(Array.from(entries.values()), (entry) => entry.startup.await, {
-    concurrency: "unbounded",
-    discard: true
-  }));
   return Service31.of({
     transform: state.transform,
     reload: state.reload,
     servers: Effect.fn("MCP.servers")(function* () {
-      return Array.from(entries).toSorted(([a], [b]) => a.localeCompare(b)).map(([name, entry]) => new ServerInfo2({ name, status: entry.status, integrationID: entry.integrationID }));
+      return Array.from(entries).toSorted(([a], [b]) => a.localeCompare(b)).map(([name, entry]) => ({ name, status: entry.status, integrationID: entry.integrationID }));
     }),
     add: Effect.fn("MCP.add")(function* (server, config) {
       const name = ServerName2.make(server);
@@ -622,7 +424,6 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       yield* state.reload();
     }),
     tools: Effect.fn("MCP.tools")(function* () {
-      yield* whenAllReady;
       return Array.from(entries.values()).flatMap((entry) => entry.tools ?? []).toSorted((a, b) => a.server.localeCompare(b.server) || a.name.localeCompare(b.name));
     }),
     callTool: Effect.fn("MCP.callTool")(function* (input) {
@@ -634,22 +435,15 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
           tool: input.name,
           message: "MCP server is not connected"
         });
-      const result = yield* target.entry.client.callTool({ name: input.name, args: input.args, sessionID: input.sessionID }).pipe(Effect.mapError((error) => new ToolCallError2({ server: target.name, tool: input.name, message: error.message })));
-      return new ToolResult2({
-        server: target.name,
-        tool: input.name,
-        isError: result.isError,
-        structured: result.structured,
-        content: result.content
-      });
+      const result = yield* recovering(target.name, target.entry, target.entry.client, (connection) => connection.callTool({ name: input.name, args: input.args, sessionID: input.sessionID })).pipe(Effect.mapError((error) => new ToolCallError2({ server: target.name, tool: input.name, message: error.message })));
+      return { ...result, server: target.name, tool: input.name };
     }),
     instructions: Effect.fn("MCP.instructions")(function* () {
-      yield* whenAllReady;
       return Array.from(entries).flatMap(([server, entry]) => {
         const instructions = entry.client?.instructions;
         if (!instructions)
           return [];
-        return [new ServerInstructions2({ server, instructions })];
+        return [{ server, instructions }];
       }).toSorted((a, b) => a.server.localeCompare(b.server));
     }),
     prompts: Effect.fn("MCP.prompts")(function* () {
@@ -660,19 +454,14 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       yield* target.entry.startup.await;
       if (!target.entry.client)
         return;
-      const result = yield* target.entry.client.prompt({ name: input.name, args: input.args }).pipe(Effect.orElseSucceed(() => {
+      const result = yield* recovering(target.name, target.entry, target.entry.client, (connection) => connection.prompt({ name: input.name, args: input.args })).pipe(Effect.orElseSucceed(() => {
         return;
       }));
       if (!result)
         return;
-      return new PromptResult2({
-        server: target.name,
-        name: input.name,
-        messages: result.messages.map((message) => new PromptMessage2({ role: message.role, content: message.content }))
-      });
+      return { ...result, server: target.name, name: input.name };
     }),
     resourceCatalog: Effect.fn("MCP.resourceCatalog")(function* () {
-      yield* whenAllReady;
       const catalogs = yield* Effect.forEach(Array.from(entries), ([name, entry]) => {
         if (!entry.client)
           return Effect.succeed({ resources: [], templates: [] });
@@ -680,8 +469,20 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
           resources: entry.client.resources().pipe(Effect.orElseSucceed(() => [])),
           templates: entry.client.resourceTemplates().pipe(Effect.orElseSucceed(() => []))
         }, { concurrency: "unbounded" }).pipe(Effect.map((catalog) => ({
-          resources: catalog.resources.map((def) => toResource(name, def)),
-          templates: catalog.templates.map((def) => toResourceTemplate(name, def))
+          resources: catalog.resources.map((resource) => Resource2.make({
+            server: name,
+            name: resource.name,
+            uri: resource.uri,
+            description: resource.description,
+            mimeType: resource.mimeType
+          })),
+          templates: catalog.templates.map((template) => ResourceTemplate2.make({
+            server: name,
+            name: template.name,
+            uriTemplate: template.uriTemplate,
+            description: template.description,
+            mimeType: template.mimeType
+          }))
         })));
       }, { concurrency: "unbounded" });
       return ResourceCatalog2.make({
@@ -694,7 +495,7 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       yield* target.entry.startup.await;
       if (!target.entry.client)
         return;
-      const result = yield* target.entry.client.readResource({ uri: input.uri }).pipe(Effect.orElseSucceed(() => {
+      const result = yield* recovering(target.name, target.entry, target.entry.client, (connection) => connection.readResource({ uri: input.uri })).pipe(Effect.orElseSucceed(() => {
         return;
       }));
       if (!result)
@@ -702,19 +503,19 @@ var layer13 = (options) => Layer.effect(Service31, Effect.gen(function* () {
       return ResourceContent2.make({
         server: target.name,
         uri: input.uri,
-        contents: result.contents
+        contents: result.contents.map((part) => ("text" in part) ? { type: "text", uri: part.uri, text: part.text, mimeType: part.mimeType } : { type: "blob", uri: part.uri, blob: part.blob, mimeType: part.mimeType })
       });
     })
   });
 }));
-function configured3(options) {
+function configured5(options) {
   return makeLocationNode({
     service: Service31,
     layer: layer13(options),
-    deps: [node78, node75, node84, node72, node70, node71]
+    deps: [node70, node69, node83, node82, node78, node79]
   });
 }
-var node35 = configured3();
+var node36 = configured5();
 function toElicitationField(key, property, required) {
   const machineTitle = /^(boolean|string|number|integer|array|object)(\s+with\b.*|\s+in\b.*)?$/i;
   const title = property.title && !machineTitle.test(property.title.trim()) ? property.title : property.description ?? key;
@@ -765,4 +566,4 @@ function toElicitationField(key, property, required) {
   }
 }
 
-export { ServerName2, PromptsChanged2, Status2, ServerInfo2, ServerInstructions2, Tool3, ToolResultContent2, ToolResult2, PromptArgument2, Prompt2, PromptMessage2, PromptResult2, Resource2, ResourceTemplate2, ResourceCatalog2, ResourceContentPart2, ResourceContent2, NotFoundError4, ToolCallError2, Service31, Options3, layer13, configured3, node35, exports_mcp4 };
+export { ServerName2, PromptsChanged2, Status2, Resource2, ResourceTemplate2, ResourceCatalog2, ResourceContentPart2, ResourceContent2, NotFoundError5, ToolCallError2, Service31, Options5, layer13, configured5, node36, exports_mcp4 };

package/dist/chunks/repository-qapv375x.js

@@ -0,0 +1,4 @@
+// src/pty/schema.ts
+import { ID as ID3 } from "@opencode/schema/pty";
+
+export { ID3 };

package/dist/chunks/{aisdk-native-yjptyezs.js → repository-qjnxxf51.js}

@@ -1,15 +1,15 @@
 import {
   PositiveInt2
-} from "./aisdk-native-922hggd3.js";
+} from "./repository-922hggd3.js";
 import {
   __export
-} from "./aisdk-native-9rqn6x4v.js";
+} from "./repository-9rqn6x4v.js";
 
 // src/v1/config/provider.ts
 var exports_provider2 = {};
 __export(exports_provider2, {
   ConfigProviderV1: () => exports_provider2,
-  Info: () => Info11,
+  Info: () => Info9,
   Model: () => Model2,
   ModelStatus: () => ModelStatus2
 });
@@ -61,7 +61,7 @@ var Model2 = Schema.Struct({
     disabled: Schema.optional(Schema.Boolean).annotate({ description: "Disable this variant for the model" })
   }), [Schema.Record(Schema.String, Schema.Any)])).annotate({ description: "Variant-specific configuration" }))
 });
-var Info11 = Schema.Struct({
+var Info9 = Schema.Struct({
   api: Schema.optional(Schema.String),
   name: Schema.optional(Schema.String),
   env: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
@@ -95,4 +95,4 @@ var Info11 = Schema.Struct({
   models: Schema.optional(Schema.Record(Schema.String, Model2))
 }).annotate({ identifier: "ProviderConfig" });
 
-export { ModelStatus2, Model2, Info11, exports_provider2 };
+export { ModelStatus2, Model2, Info9, exports_provider2 };

package/dist/chunks/{aisdk-native-219neeqh.js → repository-qkrnz1pz.js}

@@ -1,9 +1,9 @@
 import {
-  ID18
-} from "./aisdk-native-33n3bzdy.js";
+  ID16
+} from "./repository-pye8sh6e.js";
 import {
   loadSDKFactory2
-} from "./aisdk-native-hjbc5kem.js";
+} from "./repository-hjbc5kem.js";
 
 // src/plugin/provider/sap-ai-core.ts
 import { Effect } from "effect";
@@ -14,7 +14,7 @@ var SapAICorePlugin2 = define({
   effect: Effect.fn(function* (ctx) {
     const npm = yield* Npm.Service;
     yield* ctx.aisdk.hook("sdk", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== ID18.make("sap-ai-core"))
+      if (evt.model.providerID !== ID16.make("sap-ai-core"))
         return;
       const serviceKey = process.env.AICORE_SERVICE_KEY ?? (typeof evt.options.serviceKey === "string" ? evt.options.serviceKey : undefined);
       if (serviceKey && !process.env.AICORE_SERVICE_KEY)
@@ -25,7 +25,7 @@ var SapAICorePlugin2 = define({
       evt.sdk = factory(serviceKey ? { deploymentId: process.env.AICORE_DEPLOYMENT_ID, resourceGroup: process.env.AICORE_RESOURCE_GROUP } : {});
     }));
     yield* ctx.aisdk.hook("language", Effect.fn(function* (evt) {
-      if (evt.model.providerID !== ID18.make("sap-ai-core"))
+      if (evt.model.providerID !== ID16.make("sap-ai-core"))
         return;
       evt.language = evt.sdk(evt.model.modelID ?? evt.model.id);
     }));