Function makeAppsPlugin

packages/plugins/apps/src/plugin/apps-plugin.ts:550–653

(options?: AppsPluginOptions)

}

export const makeAppsPlugin = (options?: AppsPluginOptions) =>
  definePlugin(() => ({
    id: "apps",
    packageName: "@executor-js/plugin-apps",
    clientConfig: { sourceKinds: options?.sourceKinds ?? ["git", "local-directory"] },
    pluginStorage: {
      [descriptorCollection.name]: descriptorCollection,
      [toolCollection.name]: toolCollection,
      [sourceCollection.name]: sourceCollection,
    },
    storage: ({ blobs, pluginStorage }) => makeAppsStore({ blobs, pluginStorage }),
    extension: (ctx: PluginCtx<AppsStore>) => makeAppsExtension(ctx, options),
    resolveTools: ({ storage, connection }) =>
      storage.listActiveTools().pipe(
        Effect.map((tools) => ({
          tools: tools
            .filter((tool) => tool.app === String(connection.integration))
            .map(
              (tool): ToolDef => ({
                name: ToolName.make(tool.name),
                description: tool.description,
                inputSchema: tool.inputSchema,
                outputSchema: tool.outputSchema,
                annotations: {
                  ...(tool.annotations?.requiresApproval !== undefined
                    ? { requiresApproval: tool.annotations.requiresApproval }
                    : {}),
                  ...(tool.annotations?.readOnly === true ? { requiresApproval: false } : {}),
                },
              }),
            ),
        })),
      ),
    projectToolSchema: ({ ctx, toolRow, inputSchema, outputSchema }) =>
      projectAppsToolSchema(
        ctx,
        String(toolRow.integration),
        String(toolRow.name),
        inputSchema,
        outputSchema,
      ),
    validateToolArgs: ({ ctx, toolRow, args }) =>
      Effect.gen(function* () {
        const tool = yield* ctx.storage.getToolForApp(
          String(toolRow.integration),
          String(toolRow.name),
        );
        if (!tool) return;
        const resolver = makePluginCtxAppsResolver({ ctx });
        yield* resolveIntegrationBindings(tool.integrations, args, resolver);
      }),
    invokeTool: ({ ctx, toolRow, args, invokeOptions }) =>
      Effect.gen(function* () {
        const tool = yield* ctx.storage.getToolForApp(
          String(toolRow.integration),
          String(toolRow.name),
        );
        if (!tool) {