apps 0.0.1-beta.0 → 0.0.1-beta.1

package/js/graphql.js

@@ -1,46 +1,55 @@
+import {
+  catalogCache
+} from "./chunk-6YBRWRK3.js";
 import {
   protocolOperations
-} from "./chunk-LOKGDT6B.js";
+} from "./chunk-6IIO4NPI.js";
 import "./chunk-BCSNKUAC.js";
-import "./chunk-Q2FD5IBM.js";
-import "./chunk-X3YBZCJW.js";
-import "./chunk-R6JMJSVT.js";
-import "./chunk-C24KEZXR.js";
-import "./chunk-22WRQZT7.js";
-import "./chunk-HP7E42X6.js";
-import "./chunk-7JXHF5IF.js";
-import "./chunk-OWD2YICM.js";
+import {
+  cacheKey
+} from "./chunk-KOXMLKTM.js";
+import "./chunk-ZTFQHGEB.js";
+import "./chunk-NCYXZN2G.js";
+import "./chunk-RBAC33PQ.js";
+import "./chunk-PLCMJREA.js";
+import {
+  nativeOperation
+} from "./chunk-PZ36XMXW.js";
+import {
+  accountProviderError,
+  graphqlProviderError,
+  httpProviderError
+} from "./chunk-ZJWDMTE3.js";
+import "./chunk-IHQ4ML7K.js";
+import "./chunk-BMOIAIVR.js";
+import "./chunk-YEJOQEII.js";
+import "./chunk-SWPD52J7.js";
+import {
+  ProviderError
+} from "./chunk-W7D7WVSY.js";
+import "./chunk-ZCAMUXSG.js";
 import {
   FetchHttpClient_exports
-} from "./chunk-VFUZI3NY.js";
+} from "./chunk-HDJH3RPR.js";
 import {
   HttpClientRequest_exports,
   HttpClient_exports
-} from "./chunk-W7Q5EOTS.js";
+} from "./chunk-QKHR7BMF.js";
 import {
   jsonSchemaDecoder
-} from "./chunk-BPEFS4YF.js";
-import "./chunk-EP6AEUZO.js";
+} from "./chunk-2HHMABB6.js";
+import "./chunk-FZJOYIZO.js";
 import {
+  AccountId,
   HttpUrl,
   JsonObject
-} from "./chunk-36DNRFZQ.js";
+} from "./chunk-SATWJKN6.js";
 import {
   Effect_exports,
   Redacted_exports,
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
-import "./chunk-MLKGABMK.js";
-
-// src/implementation/graphql.ts
-import {
-  getIntrospectionQuery,
-  Kind as Kind2,
-  OperationTypeNode,
-  parse,
-  parseType,
-  print
-} from "graphql";
+} from "./chunk-FW5HBOIK.js";
+import "./chunk-CZ7CSFO4.js";
 
 // src/contracts/graphql.ts
 var GraphqlClientLimits = Schema_exports.Struct({
@@ -53,6 +62,7 @@ var defaultGraphqlClientLimits = GraphqlClientLimits.make({
 });
 var GraphqlToolsOptions = Schema_exports.Struct({
   url: HttpUrl,
+  accountId: Schema_exports.optional(AccountId),
   headers: Schema_exports.optional(Schema_exports.Record(Schema_exports.String, Schema_exports.String)),
   signal: Schema_exports.optional(Schema_exports.instanceOf(AbortSignal)),
   timeoutMs: Schema_exports.optional(
@@ -121,8 +131,26 @@ var GraphqlResponse = Schema_exports.Struct({
   data: Schema_exports.optional(Schema_exports.NullOr(JsonObject)),
   errors: Schema_exports.optional(Schema_exports.Array(JsonObject))
 });
+var GraphqlToolDefinition = Schema_exports.Struct({
+  name: Name,
+  kind: Schema_exports.Literals(["query", "mutation"]),
+  field: Name,
+  description: Schema_exports.String,
+  arguments: Schema_exports.Array(Schema_exports.Struct({ name: Name, type: Schema_exports.String })),
+  inputSchema: JsonObject,
+  composite: Schema_exports.Boolean,
+  selection: Schema_exports.String
+});
 
 // src/implementation/graphql.ts
+import {
+  getIntrospectionQuery,
+  Kind as Kind2,
+  OperationTypeNode,
+  parse,
+  parseType,
+  print
+} from "graphql";
 function wrapped(type) {
   if (!type.ofType) throw new GraphqlError({ phase: "discover", reason: "invalid_response" });
   return type.ofType;
@@ -136,8 +164,7 @@ function typeName(type) {
   if (!type.name) throw new GraphqlError({ phase: "discover", reason: "invalid_response" });
   return type.name;
 }
-function fieldInput(field, catalog) {
-  const types = new Map(catalog.__schema.types.map((type) => [type.name, type]));
+function fieldInput(field, types) {
   const definitions = /* @__PURE__ */ new Map();
   const convert = (ref) => ref.kind === "NON_NULL" ? nonNull(wrapped(ref)) : { anyOf: [nonNull(ref), { type: "null" }] };
   const nonNull = (ref) => {
@@ -221,7 +248,7 @@ function selection(text) {
     throw new GraphqlError({ phase: "call", reason: "invalid_input" });
   return field.selectionSet;
 }
-var graphqlToolsEffect = (input) => Effect_exports.gen(function* () {
+var graphqlClientEffect = (input) => Effect_exports.gen(function* () {
   const options = yield* Schema_exports.decodeUnknownEffect(GraphqlToolsOptions)(input).pipe(
     Effect_exports.mapError(() => new GraphqlError({ phase: "discover", reason: "invalid_input" }))
   );
@@ -234,23 +261,21 @@ var graphqlToolsEffect = (input) => Effect_exports.gen(function* () {
       const client = yield* HttpClient_exports.HttpClient;
       const response = yield* HttpClient_exports.withScope(client).execute(
         HttpClientRequest_exports.post(url.href).pipe(
+          // GitHub requires this header; Workers do not supply one by default.
+          HttpClientRequest_exports.setHeader("user-agent", "Executor"),
           HttpClientRequest_exports.setHeaders(Redacted_exports.value(headers)),
           HttpClientRequest_exports.bodyJsonUnsafe({ query, variables })
         )
       );
       if (response.status < 200 || response.status >= 300)
-        return yield* new GraphqlError({
-          phase,
-          reason: [401, 403].includes(response.status) ? "unauthorized" : "request",
-          status: response.status
-        });
+        return yield* httpProviderError(response.status, response.headers) ?? new GraphqlError({ phase, reason: "request", status: response.status });
       const result = yield* response.json.pipe(
         Effect_exports.withSpan("provider.http.response.read"),
         Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(GraphqlResponse)),
         Effect_exports.mapError(() => new GraphqlError({ phase, reason: "invalid_response" }))
       );
       if (result.errors?.length)
-        return yield* new GraphqlError({ phase, reason: "execution", status: response.status });
+        return yield* graphqlProviderError(result.errors, response.status) ?? new GraphqlError({ phase, reason: "execution", status: response.status });
       if (result.data == null)
         return yield* new GraphqlError({ phase, reason: "invalid_response" });
       return result.data;
@@ -270,15 +295,19 @@ var graphqlToolsEffect = (input) => Effect_exports.gen(function* () {
       orElse: () => Effect_exports.fail(new GraphqlError({ phase, reason: "timeout" }))
     }),
     Effect_exports.mapError(
-      (error) => error instanceof GraphqlError ? error : new GraphqlError({ phase, reason: "request" })
+      (error) => error instanceof ProviderError && options.accountId !== void 0 ? accountProviderError(error, options.accountId) : error instanceof GraphqlError || error instanceof ProviderError ? error : new GraphqlError({ phase, reason: "request" })
     )
   );
-  const catalog = yield* request("discover", getIntrospectionQuery()).pipe(
+  const discover = request("discover", getIntrospectionQuery()).pipe(
     Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(GraphqlIntrospection)),
     Effect_exports.mapError(
-      (error) => error instanceof GraphqlError ? error : new GraphqlError({ phase: "discover", reason: "invalid_response" })
+      (error) => error instanceof GraphqlError || error instanceof ProviderError ? error : new GraphqlError({ phase: "discover", reason: "invalid_response" })
     )
   );
+  return { request, discover };
+});
+var graphqlDefinitions = (catalog) => Effect_exports.gen(function* () {
+  const types = new Map(catalog.__schema.types.map((type) => [type.name, type]));
   const roots = [
     { kind: OperationTypeNode.QUERY, type: catalog.__schema.queryType },
     { kind: OperationTypeNode.MUTATION, type: catalog.__schema.mutationType }
@@ -287,103 +316,176 @@ var graphqlToolsEffect = (input) => Effect_exports.gen(function* () {
       (field) => ({ kind, field })
     )
   );
-  const entries = yield* Effect_exports.forEach(
+  return yield* Effect_exports.forEach(
     roots,
     ({ kind, field }) => Effect_exports.gen(function* () {
       const definition = yield* Effect_exports.try({
-        try: () => fieldInput(field, catalog),
+        try: () => fieldInput(field, types),
         catch: () => new GraphqlError({ phase: "discover", reason: "invalid_response" })
       });
-      const decoder = yield* jsonSchemaDecoder(definition.schema).pipe(
-        Effect_exports.mapError(
-          () => new GraphqlError({ phase: "discover", reason: "invalid_response" })
-        )
+      return yield* Effect_exports.try({
+        try: () => ({
+          name: kind + "_" + field.name,
+          kind,
+          field: field.name,
+          description: field.description ?? field.name,
+          arguments: field.args.map((arg) => ({ name: arg.name, type: typeName(arg.type) })),
+          inputSchema: definition.schema,
+          composite: definition.composite,
+          selection: definition.selection
+        }),
+        catch: () => new GraphqlError({ phase: "discover", reason: "invalid_response" })
+      });
+    })
+  );
+});
+var adaptGraphqlTool = (client, definition) => Effect_exports.gen(function* () {
+  const decoder = yield* jsonSchemaDecoder(definition.inputSchema).pipe(
+    Effect_exports.mapError(() => new GraphqlError({ phase: "discover", reason: "invalid_response" }))
+  );
+  const kind = definition.kind === "query" ? OperationTypeNode.QUERY : OperationTypeNode.MUTATION;
+  const name = definition.name;
+  const tool = {
+    description: definition.description,
+    readOnly: kind === OperationTypeNode.QUERY,
+    input: decoder,
+    run: (_context, input) => Effect_exports.gen(function* () {
+      const args = yield* Schema_exports.decodeUnknownEffect(decoder)(input).pipe(
+        Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonObject)),
+        Effect_exports.mapError(() => new GraphqlError({ phase: "call", reason: "invalid_input" }))
+      );
+      const variables = yield* Schema_exports.decodeUnknownEffect(JsonObject)(
+        args.arguments ?? {}
+      ).pipe(
+        Effect_exports.mapError(() => new GraphqlError({ phase: "call", reason: "invalid_input" }))
       );
-      const name = kind + "_" + field.name;
-      const tool = {
-        description: field.description ?? field.name,
-        readOnly: kind === OperationTypeNode.QUERY,
-        input: decoder,
-        run: (_context, input2) => Effect_exports.gen(function* () {
-          const args = yield* Schema_exports.decodeUnknownEffect(decoder)(input2).pipe(
-            Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(JsonObject)),
-            Effect_exports.mapError(() => new GraphqlError({ phase: "call", reason: "invalid_input" }))
-          );
-          const variables = yield* Schema_exports.decodeUnknownEffect(JsonObject)(
-            args.arguments ?? {}
-          ).pipe(
-            Effect_exports.mapError(() => new GraphqlError({ phase: "call", reason: "invalid_input" }))
-          );
-          const query = yield* Effect_exports.try({
-            try: () => {
-              const used = field.args.filter((arg) => Object.hasOwn(variables, arg.name));
-              return print({
-                kind: Kind2.DOCUMENT,
-                definitions: [
-                  {
-                    kind: Kind2.OPERATION_DEFINITION,
-                    operation: kind,
-                    variableDefinitions: used.map((arg) => ({
-                      kind: Kind2.VARIABLE_DEFINITION,
-                      variable: {
-                        kind: Kind2.VARIABLE,
-                        name: { kind: Kind2.NAME, value: arg.name }
-                      },
-                      type: parseType(typeName(arg.type))
-                    })),
-                    selectionSet: {
-                      kind: Kind2.SELECTION_SET,
-                      selections: [
-                        {
-                          kind: Kind2.FIELD,
-                          name: { kind: Kind2.NAME, value: field.name },
-                          arguments: used.map((arg) => ({
-                            kind: Kind2.ARGUMENT,
-                            name: { kind: Kind2.NAME, value: arg.name },
-                            value: {
-                              kind: Kind2.VARIABLE,
-                              name: { kind: Kind2.NAME, value: arg.name }
-                            }
-                          })),
-                          ...definition.composite ? {
-                            selectionSet: selection(
-                              typeof args.select === "string" ? args.select : definition.selection
-                            )
-                          } : {}
+      const query = yield* Effect_exports.try({
+        try: () => {
+          const used = definition.arguments.filter((arg) => Object.hasOwn(variables, arg.name));
+          return print({
+            kind: Kind2.DOCUMENT,
+            definitions: [
+              {
+                kind: Kind2.OPERATION_DEFINITION,
+                operation: kind,
+                variableDefinitions: used.map((arg) => ({
+                  kind: Kind2.VARIABLE_DEFINITION,
+                  variable: {
+                    kind: Kind2.VARIABLE,
+                    name: { kind: Kind2.NAME, value: arg.name }
+                  },
+                  type: parseType(arg.type)
+                })),
+                selectionSet: {
+                  kind: Kind2.SELECTION_SET,
+                  selections: [
+                    {
+                      kind: Kind2.FIELD,
+                      name: { kind: Kind2.NAME, value: definition.field },
+                      arguments: used.map((arg) => ({
+                        kind: Kind2.ARGUMENT,
+                        name: { kind: Kind2.NAME, value: arg.name },
+                        value: {
+                          kind: Kind2.VARIABLE,
+                          name: { kind: Kind2.NAME, value: arg.name }
                         }
-                      ]
+                      })),
+                      ...definition.composite ? {
+                        selectionSet: selection(
+                          typeof args.select === "string" ? args.select : definition.selection
+                        )
+                      } : {}
                     }
-                  }
-                ]
-              });
-            },
-            catch: () => new GraphqlError({ phase: "call", reason: "invalid_input" })
+                  ]
+                }
+              }
+            ]
           });
-          const data = yield* request("call", query, variables);
-          const value = Object.hasOwn(data, field.name) ? data[field.name] : void 0;
-          if (value === void 0)
-            return yield* new GraphqlError({ phase: "call", reason: "invalid_response" });
-          return value;
-        }).pipe(
-          Effect_exports.withSpan("provider.graphql.call", {
-            attributes: {
-              "graphql.operation.type": kind,
-              "executor.tool.name": name
-            }
-          })
-        )
-      };
-      return [name, tool];
-    })
+        },
+        catch: () => new GraphqlError({ phase: "call", reason: "invalid_input" })
+      });
+      const data = yield* client.request("call", query, variables);
+      const value = Object.hasOwn(data, definition.field) ? data[definition.field] : void 0;
+      if (value === void 0)
+        return yield* new GraphqlError({ phase: "call", reason: "invalid_response" });
+      return value;
+    }).pipe(
+      Effect_exports.withSpan("provider.graphql.call", {
+        attributes: {
+          "graphql.operation.type": kind,
+          "executor.tool.name": name
+        }
+      })
+    )
+  };
+  return tool;
+});
+
+// src/implementation/graphql-catalog.ts
+var GraphqlToolSummary = GraphqlToolDefinition.mapFields(({ name, kind, description }) => ({
+  name,
+  kind,
+  description
+}));
+var graphqlCatalog = (options, kinds) => Effect_exports.gen(function* () {
+  const parsed = yield* Schema_exports.decodeUnknownEffect(GraphqlToolsOptions)(options).pipe(
+    Effect_exports.mapError(() => new GraphqlError({ phase: "discover", reason: "invalid_input" }))
   );
-  return Object.fromEntries(entries);
+  const headers = {};
+  new Headers(parsed.headers).forEach((value, name) => {
+    headers[name] = value;
+  });
+  const id = yield* cacheKey({ url: parsed.url, headers, accountId: parsed.accountId ?? null });
+  const client = yield* graphqlClientEffect(parsed);
+  const catalog = yield* catalogCache({
+    ...options,
+    prefix: ["graphql-catalog-v2", id],
+    schema: GraphqlToolDefinition,
+    summary: {
+      schema: GraphqlToolSummary,
+      of: ({ name, kind, description }) => ({ name, kind, description })
+    },
+    load: (context) => (context === void 0 ? Effect_exports.succeed(client) : graphqlClientEffect({ ...parsed, signal: context.signal })).pipe(
+      Effect_exports.flatMap((source) => source.discover),
+      Effect_exports.flatMap(graphqlDefinitions)
+    )
+  });
+  const kindOf = (tool) => Object.hasOwn(kinds, tool.name) ? kinds[tool.name] ?? "mutation" : tool.kind;
+  const qualified = (tool) => `${kindOf(tool) === "query" ? "queries" : "mutations"}.${tool.name}`;
+  const summarize = (tool) => ({
+    name: qualified(tool),
+    description: tool.description,
+    readOnly: kindOf(tool) === "query"
+  });
+  const describe = (tool) => ({
+    ...summarize(tool),
+    inputSchema: tool.inputSchema
+  });
+  const selected = (name) => Effect_exports.gen(function* () {
+    if (!name.startsWith("queries.") && !name.startsWith("mutations.")) return void 0;
+    const tool = yield* catalog.resolve(name.slice(name.indexOf(".") + 1));
+    return tool === void 0 || qualified(tool) !== name ? void 0 : tool;
+  });
+  const dynamicTools = {
+    list: () => catalog.list().pipe(Effect_exports.map((tools) => tools.map(describe))),
+    summaries: () => catalog.summaries().pipe(Effect_exports.map((tools) => tools.map(summarize))),
+    describe: (name) => selected(name).pipe(
+      Effect_exports.map((tool) => tool === void 0 ? void 0 : describe(tool))
+    ),
+    resolve: (name) => Effect_exports.gen(function* () {
+      const tool = yield* selected(name);
+      if (tool === void 0) return void 0;
+      const adapted = yield* adaptGraphqlTool(client, tool);
+      const operations = protocolOperations({ selected: adapted }, { selected: kindOf(tool) });
+      return nativeOperation(operations.queries.selected ?? operations.mutations.selected);
+    })
+  };
+  return { dynamicTools };
 });
 
 // src/graphql.ts
 var graphqlOperations = (options, kinds = {}) => Effect_exports.runPromise(
-  graphqlToolsEffect(options).pipe(
-    Effect_exports.map((operations) => protocolOperations(operations, kinds))
-  ),
+  graphqlCatalog(options, kinds),
   options.signal === void 0 ? {} : { signal: options.signal }
 );
 export {

package/js/host.js

@@ -1,43 +1,98 @@
 import {
   createAppHandler
-} from "./chunk-Q2FD5IBM.js";
-import "./chunk-X3YBZCJW.js";
-import "./chunk-R6JMJSVT.js";
-import "./chunk-C24KEZXR.js";
+} from "./chunk-KOXMLKTM.js";
+import "./chunk-ZTFQHGEB.js";
+import "./chunk-NCYXZN2G.js";
 import {
+  CacheCommand,
+  CacheError,
+  CacheReply
+} from "./chunk-RBAC33PQ.js";
+import "./chunk-PLCMJREA.js";
+import "./chunk-PZ36XMXW.js";
+import "./chunk-ZJWDMTE3.js";
+import {
+  ElicitationFailed,
+  ElicitationReply,
   HostAccountsInvalid,
   HostInputInvalid,
   HostResponse,
   ResolvedAccounts,
-  TrustedToolApproval
-} from "./chunk-22WRQZT7.js";
-import {
-  ElicitationFailed,
-  ElicitationReply,
+  TrustedToolApproval,
   WorkflowFailure,
   WorkflowRpcResult,
   WorkflowRun,
   WorkflowRunId,
   WorkflowRunPage
-} from "./chunk-HP7E42X6.js";
-import "./chunk-7JXHF5IF.js";
+} from "./chunk-IHQ4ML7K.js";
+import "./chunk-BMOIAIVR.js";
+import "./chunk-YEJOQEII.js";
+import "./chunk-SWPD52J7.js";
+import "./chunk-W7D7WVSY.js";
 import {
   collectTelemetry,
   withRemoteSpan
-} from "./chunk-OWD2YICM.js";
-import "./chunk-VFUZI3NY.js";
-import "./chunk-W7Q5EOTS.js";
-import "./chunk-BPEFS4YF.js";
-import "./chunk-EP6AEUZO.js";
-import "./chunk-36DNRFZQ.js";
+} from "./chunk-ZCAMUXSG.js";
+import "./chunk-HDJH3RPR.js";
+import "./chunk-QKHR7BMF.js";
+import "./chunk-2HHMABB6.js";
+import "./chunk-FZJOYIZO.js";
+import "./chunk-SATWJKN6.js";
 import {
   Cause_exports,
   Effect_exports,
   Redacted_exports,
   Scheduler_exports,
   Schema_exports
-} from "./chunk-2OTCEKL2.js";
-import "./chunk-MLKGABMK.js";
+} from "./chunk-FW5HBOIK.js";
+import "./chunk-CZ7CSFO4.js";
+
+// src/implementation/cache-session.ts
+var isolatedCacheSession = (callback) => {
+  const controller = new AbortController();
+  const pending = /* @__PURE__ */ new Set();
+  const cache = {
+    transport: (command) => Effect_exports.tryPromise({
+      try: () => callback(Schema_exports.encodeSync(CacheCommand)(command)),
+      catch: () => new CacheError({ reason: "storage" })
+    }).pipe(
+      Effect_exports.flatMap(Schema_exports.decodeUnknownEffect(CacheReply)),
+      Effect_exports.mapError(() => new CacheError({ reason: "storage" })),
+      Effect_exports.flatMap(
+        (reply) => reply.ok ? Effect_exports.succeed(reply.value) : Effect_exports.fail(reply.error)
+      )
+    ),
+    background: (task) => Effect_exports.gen(function* () {
+      const services = yield* Effect_exports.context();
+      const promise = Effect_exports.runPromiseWith(services)(
+        task.pipe(
+          Effect_exports.timeout("30 seconds"),
+          Effect_exports.catchCause(() => Effect_exports.logWarning("App cache refresh failed"))
+        ),
+        { signal: controller.signal }
+      ).then(
+        () => {
+          pending.delete(promise);
+        },
+        () => {
+          pending.delete(promise);
+        }
+      );
+      pending.add(promise);
+    })
+  };
+  const drain = async () => {
+    while (pending.size > 0) await Promise.all(pending);
+  };
+  return {
+    cache,
+    drain,
+    cancel: async () => {
+      controller.abort();
+      await drain();
+    }
+  };
+};
 
 // src/implementation/workflow-rpc.ts
 var isolatedWorkflowExecution = (run, deliver, signal) => {
@@ -187,6 +242,7 @@ export {
   createAppHandler2 as createAppHandler,
   createIsolatedAppHandler,
   hostContext,
+  isolatedCacheSession,
   isolatedElicitation,
   isolatedWorkflowControls,
   isolatedWorkflowExecution