@yolk-sdk/connectors 0.0.1-canary.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yolk SDK 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/README.md

@@ -0,0 +1,195 @@
+# @yolk-sdk/connectors
+
+Effect-native connector primitives for hosts that bring their own auth, storage, and policy.
+
+## Install
+
+```bash
+pnpm add @yolk-sdk/connectors@canary effect
+```
+
+Canary APIs are unstable. Keep all `@yolk-sdk/*` packages on the same version.
+
+## Subpaths
+
+| Subpath | Purpose |
+| --- | --- |
+| `@yolk-sdk/connectors` | Core connector/action/integration/credential primitives |
+| `@yolk-sdk/connectors/agent` | Adapter from connector actions to `@yolk-sdk/agent/tools` modules |
+| `@yolk-sdk/connectors/figma` | Figma remote MCP auth action and OAuth constants |
+| `@yolk-sdk/connectors/google` | Gmail/Calendar actions and Google OAuth slot constants |
+| `@yolk-sdk/connectors/linkedin-search` | Exa people search and Enrich Layer profile/email actions |
+| `@yolk-sdk/connectors/notion` | Notion search/page actions and API token slot constants |
+| `@yolk-sdk/connectors/r2-storage` | Cloudflare R2 upload URL action with host-provided presigner |
+| `@yolk-sdk/connectors/telegram` | Telegram bot send/validate actions |
+| `@yolk-sdk/connectors/todoist` | Todoist task actions and API token slot constants |
+
+## Imports
+
+```ts
+import { defineConnector, makeIntegration } from '@yolk-sdk/connectors'
+import { makeConnectorToolModule } from '@yolk-sdk/connectors/agent'
+import { GoogleConnector } from '@yolk-sdk/connectors/google'
+```
+
+## Model
+
+- **Connector**: reusable provider logic.
+- **Integration**: host-owned config that makes a connector invokable.
+- **Action**: typed operation exposed by a connector.
+- **CredentialSlot**: credential requirement declared by connector code.
+- **CredentialBinding**: integration slot-to-host-credential-ref mapping.
+- **CredentialResolver**: host Effect service that resolves refs at runtime.
+- **ConnectorHttpClient**: host-provided HTTP port used by provider actions.
+
+## HTTP port
+
+`src/http.ts` is connector infrastructure, not a connector. It defines the typed HTTP request/response model, the `ConnectorHttpClient` Effect service, and JSON response decoding helpers.
+
+Provider connectors build `ConnectorHttpRequest` values; hosts execute them by providing a `ConnectorHttpClient` layer. This keeps connector packages portable and avoids bundling `fetch`, Node HTTP clients, or app-specific networking policy.
+
+Host adapters must preserve connector headers and body content type. Several provider actions send JSON and rely on `content-type: application/json` reaching the upstream API unchanged.
+
+## Example
+
+```ts
+import { Effect, Layer, Schema } from 'effect'
+import {
+  ActionResult,
+  ApiKeyCredential,
+  CredentialResolver,
+  CredentialSlot,
+  defineAction,
+  defineConnector,
+  makeCredentialBinding,
+  makeIntegration,
+  resolveCredential
+} from '@yolk-sdk/connectors'
+
+const ApiToken = CredentialSlot.make({
+  id: 'todoist.api_token',
+  kind: 'api_key'
+})
+
+const ListTasksInput = Schema.Struct({ projectId: Schema.optional(Schema.String) })
+const ListTasksOutput = Schema.Struct({ tasks: Schema.Array(Schema.String) })
+
+const listTasks = defineAction({
+  id: 'todoist.list_tasks',
+  description: 'List Todoist tasks',
+  inputSchema: ListTasksInput,
+  outputSchema: ListTasksOutput,
+  execute: input =>
+    Effect.gen(function* () {
+      const credential = yield* resolveCredential(input.integration, ApiToken)
+
+      if (credential._tag !== 'ApiKeyCredential') {
+        return ActionResult.failure({ code: 'invalid_credential', message: 'Expected API key' })
+      }
+
+      return ActionResult.success({ tasks: [] })
+    })
+})
+
+const Todoist = defineConnector({
+  id: 'todoist',
+  actions: [listTasks]
+})
+
+const integration = makeIntegration({
+  connectorId: 'todoist',
+  credentialBindings: [
+    makeCredentialBinding({ slotId: ApiToken.id, credentialRef: 'host-credential-id' })
+  ]
+})
+
+const CredentialResolverLive = Layer.succeed(
+  CredentialResolver,
+  CredentialResolver.of({
+    resolve: () =>
+      Effect.succeed(
+        ApiKeyCredential.make({
+          _tag: 'ApiKeyCredential',
+          key: 'runtime-secret-from-host'
+        })
+      )
+  })
+)
+
+const program = Todoist.invoke({
+  integration,
+  action: 'todoist.list_tasks',
+  input: {}
+}).pipe(Effect.provide(CredentialResolverLive))
+```
+
+## Google connector
+
+```ts
+import { Effect } from 'effect'
+import {
+  makeCredentialBinding,
+  makeIntegration
+} from '@yolk-sdk/connectors'
+import { GoogleConnector, GoogleOAuthCredentialSlot } from '@yolk-sdk/connectors/google'
+
+const integration = makeIntegration({
+  connectorId: 'google',
+  credentialBindings: [
+    makeCredentialBinding({
+      slotId: GoogleOAuthCredentialSlot.id,
+      credentialRef: 'google-oauth-credential'
+    })
+  ]
+})
+
+const result = GoogleConnector.invoke({
+  integration,
+  action: 'gmail.search',
+  input: { query: 'from:alice@example.com', maxResults: 10 }
+})
+```
+
+Provide `CredentialResolver` and `ConnectorHttpClient` layers from host code. Hosts own OAuth refresh before returning `OAuthCredential`. If using Effect HTTP, adapt `effect/unstable/http` in host code rather than importing a Yolk wrapper. Preserve connector request headers and body content type when adapting HTTP; provider connectors may rely on `content-type: application/json` for request parsing.
+
+## Provider actions
+
+| Subpath | Actions |
+| --- | --- |
+| `@yolk-sdk/connectors/figma` | `figma.mcp_auth` |
+| `@yolk-sdk/connectors/google` | `gmail.search`, `gmail.get_message`, `calendar.list_events`, `calendar.create_event` |
+| `@yolk-sdk/connectors/linkedin-search` | `linkedin_search.search`, `linkedin_search.profile`, `linkedin_search.email` |
+| `@yolk-sdk/connectors/notion` | `notion.search`, `notion.get_page`, `notion.create_page` |
+| `@yolk-sdk/connectors/r2-storage` | `r2_storage.upload_url` |
+| `@yolk-sdk/connectors/telegram` | `telegram.send_message`, `telegram.validate` |
+| `@yolk-sdk/connectors/todoist` | `todoist.list_tasks`, `todoist.create_task`, `todoist.close_task` |
+
+R2 presigning is host-provided through `R2Presigner`; no AWS SDK dependency is bundled.
+
+## Agent adapter
+
+```ts
+import { makeConnectorToolModule } from '@yolk-sdk/connectors/agent'
+import { GoogleConnector } from '@yolk-sdk/connectors/google'
+
+const toolModule = makeConnectorToolModule(GoogleConnector, {
+  integration,
+  layer: HostConnectorLayer,
+  access: action => action.includes('create') ? 'write' : 'read'
+})
+```
+
+`HostConnectorLayer` should provide `CredentialResolver`, `ConnectorHttpClient`, and any other connector dependencies.
+
+## Host responsibilities
+
+- Store, encrypt, refresh, revoke, and audit credentials.
+- Own OAuth routes, callbacks, state, and token persistence.
+- Map integrations to users, workspaces, agents, or projects outside this package.
+- Authorize action execution before invoking connectors.
+
+## Boundaries
+
+- No DB, framework, UI, app auth, or product lifecycle code.
+- No Promise facade; use Effect directly.
+- Integrations contain credential refs only, never raw secrets.

package/dist/action.d.mts

@@ -0,0 +1,37 @@
+import { ConnectorError } from "./error.mjs";
+import { ActionResult } from "./result.mjs";
+import { ConnectorIntegration } from "./integration.mjs";
+import { Effect } from "effect";
+import * as Schema from "effect/Schema";
+
+//#region src/action.d.ts
+type ActionInputSchema = Schema.Schema<unknown> & {
+  readonly DecodingServices: never;
+};
+type ActionOutputSchema = Schema.Schema<unknown>;
+type ActionExecutionInput<Input> = {
+  readonly integration: ConnectorIntegration;
+  readonly input: Input;
+};
+type UnknownActionExecutionInput = {
+  readonly integration: ConnectorIntegration;
+  readonly input: unknown;
+};
+type ConnectorAction<Env = never, Error = never> = {
+  readonly id: string;
+  readonly description?: string;
+  readonly inputSchema: ActionInputSchema;
+  readonly outputSchema: ActionOutputSchema;
+  readonly execute: (input: UnknownActionExecutionInput) => Effect.Effect<ActionResult<unknown>, Error | ConnectorError, Env>;
+};
+type DefineActionOptions<InputSchema extends ActionInputSchema, Output, Env, Error> = {
+  readonly id: string;
+  readonly description?: string;
+  readonly inputSchema: InputSchema;
+  readonly outputSchema: Schema.Schema<Output>;
+  readonly execute: (input: ActionExecutionInput<InputSchema['Type']>) => Effect.Effect<ActionResult<Output>, Error | ConnectorError, Env>;
+};
+declare const defineAction: <InputSchema extends ActionInputSchema, Output, Env = never, Error = never>(options: DefineActionOptions<InputSchema, Output, Env, Error>) => ConnectorAction<Env, Error>;
+//#endregion
+export { ActionExecutionInput, ConnectorAction, DefineActionOptions, UnknownActionExecutionInput, defineAction };
+//# sourceMappingURL=action.d.mts.map

package/dist/action.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.d.mts","names":[],"sources":["../src/action.ts"],"mappings":";;;;;;;KAMK,iBAAA,GAAoB,MAAA,CAAO,MAAM;EAAA,SAAuB,gBAAA;AAAA;AAAA,KACxD,kBAAA,GAAqB,MAAA,CAAO,MAAM;AAAA,KAE3B,oBAAA;EAAA,SACD,WAAA,EAAa,oBAAA;EAAA,SACb,KAAA,EAAO,KAAK;AAAA;AAAA,KAGX,2BAAA;EAAA,SACD,WAAA,EAAa,oBAAoB;EAAA,SACjC,KAAA;AAAA;AAAA,KAGC,eAAA;EAAA,SACD,EAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,iBAAA;EAAA,SACb,YAAA,EAAc,kBAAA;EAAA,SACd,OAAA,GACP,KAAA,EAAO,2BAAA,KACJ,MAAA,CAAO,MAAA,CAAO,YAAA,WAAuB,KAAA,GAAQ,cAAA,EAAgB,GAAA;AAAA;AAAA,KAGxD,mBAAA,qBACU,iBAAA;EAAA,SAKX,EAAA;EAAA,SACA,WAAA;EAAA,SACA,WAAA,EAAa,WAAA;EAAA,SACb,YAAA,EAAc,MAAA,CAAO,MAAA,CAAO,MAAA;EAAA,SAC5B,OAAA,GACP,KAAA,EAAO,oBAAA,CAAqB,WAAA,cACzB,MAAA,CAAO,MAAA,CAAO,YAAA,CAAa,MAAA,GAAS,KAAA,GAAQ,cAAA,EAAgB,GAAA;AAAA;AAAA,cAWtD,YAAA,uBACS,iBAAA,sCAKpB,OAAA,EAAS,mBAAA,CAAoB,WAAA,EAAa,MAAA,EAAQ,GAAA,EAAK,KAAA,MACtD,eAAA,CAAgB,GAAA,EAAK,KAAA"}

package/dist/action.mjs

@@ -0,0 +1,24 @@
+import { ConnectorError } from "./error.mjs";
+import { Effect } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/action.ts
+const validationError = (actionId, error) => new ConnectorError({
+	cause: "validation_failed",
+	message: `Invalid input for action: ${actionId}`,
+	actionId,
+	underlying: error
+});
+const defineAction = (options) => ({
+	id: options.id,
+	description: options.description,
+	inputSchema: options.inputSchema,
+	outputSchema: options.outputSchema,
+	execute: (input) => Schema.decodeUnknownEffect(options.inputSchema)(input.input).pipe(Effect.mapError((error) => validationError(options.id, error)), Effect.flatMap((params) => options.execute({
+		integration: input.integration,
+		input: params
+	})))
+});
+//#endregion
+export { defineAction };
+
+//# sourceMappingURL=action.mjs.map

package/dist/action.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"action.mjs","names":[],"sources":["../src/action.ts"],"sourcesContent":["import { Effect } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { ConnectorError } from './error.ts'\nimport type { ActionResult } from './result.ts'\nimport type { ConnectorIntegration } from './integration.ts'\n\ntype ActionInputSchema = Schema.Schema<unknown> & { readonly DecodingServices: never }\ntype ActionOutputSchema = Schema.Schema<unknown>\n\nexport type ActionExecutionInput<Input> = {\n  readonly integration: ConnectorIntegration\n  readonly input: Input\n}\n\nexport type UnknownActionExecutionInput = {\n  readonly integration: ConnectorIntegration\n  readonly input: unknown\n}\n\nexport type ConnectorAction<Env = never, Error = never> = {\n  readonly id: string\n  readonly description?: string\n  readonly inputSchema: ActionInputSchema\n  readonly outputSchema: ActionOutputSchema\n  readonly execute: (\n    input: UnknownActionExecutionInput\n  ) => Effect.Effect<ActionResult<unknown>, Error | ConnectorError, Env>\n}\n\nexport type DefineActionOptions<\n  InputSchema extends ActionInputSchema,\n  Output,\n  Env,\n  Error\n> = {\n  readonly id: string\n  readonly description?: string\n  readonly inputSchema: InputSchema\n  readonly outputSchema: Schema.Schema<Output>\n  readonly execute: (\n    input: ActionExecutionInput<InputSchema['Type']>\n  ) => Effect.Effect<ActionResult<Output>, Error | ConnectorError, Env>\n}\n\nconst validationError = (actionId: string, error: unknown) =>\n  new ConnectorError({\n    cause: 'validation_failed',\n    message: `Invalid input for action: ${actionId}`,\n    actionId,\n    underlying: error\n  })\n\nexport const defineAction = <\n  InputSchema extends ActionInputSchema,\n  Output,\n  Env = never,\n  Error = never\n>(\n  options: DefineActionOptions<InputSchema, Output, Env, Error>\n): ConnectorAction<Env, Error> => ({\n  id: options.id,\n  description: options.description,\n  inputSchema: options.inputSchema,\n  outputSchema: options.outputSchema,\n  execute: input =>\n    Schema.decodeUnknownEffect(options.inputSchema)(input.input).pipe(\n      Effect.mapError(error => validationError(options.id, error)),\n      Effect.flatMap(params =>\n        options.execute({\n          integration: input.integration,\n          input: params\n        })\n      )\n    )\n})\n"],"mappings":";;;;AA4CA,MAAM,mBAAmB,UAAkB,UACzC,IAAI,eAAe;CACjB,OAAO;CACP,SAAS,6BAA6B;CACtC;CACA,YAAY;AACd,CAAC;AAEH,MAAa,gBAMX,aACiC;CACjC,IAAI,QAAQ;CACZ,aAAa,QAAQ;CACrB,aAAa,QAAQ;CACrB,cAAc,QAAQ;CACtB,UAAS,UACP,OAAO,oBAAoB,QAAQ,WAAW,EAAE,MAAM,KAAK,EAAE,KAC3D,OAAO,UAAS,UAAS,gBAAgB,QAAQ,IAAI,KAAK,CAAC,GAC3D,OAAO,SAAQ,WACb,QAAQ,QAAQ;EACd,aAAa,MAAM;EACnB,OAAO;CACT,CAAC,CACH,CACF;AACJ"}

package/dist/agent.d.mts

@@ -0,0 +1,21 @@
+import { ConnectorIntegration } from "./integration.mjs";
+import { Connector } from "./connector.mjs";
+import { Effect, Layer } from "effect";
+import { ToolError } from "@yolk-sdk/agent/loop";
+import { ToolAccess, ToolModule, ToolRegistration } from "@yolk-sdk/agent/tools";
+
+//#region src/agent.d.ts
+type ConnectorIntegrationResolver<Context> = ConnectorIntegration | ((context: Context) => Effect.Effect<ConnectorIntegration, ToolError>);
+type ConnectorToolAccessResolver = ToolAccess | ((actionId: string) => ToolAccess);
+type MakeConnectorToolModuleOptions<Context, Env> = {
+  readonly integration: ConnectorIntegrationResolver<Context>;
+  readonly layer: Layer.Layer<Env>;
+  readonly moduleId?: string;
+  readonly namePrefix?: string;
+  readonly access?: ConnectorToolAccessResolver;
+};
+declare const makeConnectorToolRegistration: <Context, Env = never, Error = never>(connector: Connector<Env, Error>, actionId: string, options: MakeConnectorToolModuleOptions<Context, Env>) => ToolRegistration<Context>;
+declare const makeConnectorToolModule: <Context, Env = never, Error = never>(connector: Connector<Env, Error>, options: MakeConnectorToolModuleOptions<Context, Env>) => ToolModule<Context>;
+//#endregion
+export { ConnectorIntegrationResolver, ConnectorToolAccessResolver, MakeConnectorToolModuleOptions, makeConnectorToolModule, makeConnectorToolRegistration };
+//# sourceMappingURL=agent.d.mts.map

package/dist/agent.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.d.mts","names":[],"sources":["../src/agent.ts"],"mappings":";;;;;;;KAUY,4BAAA,YACR,oBAAA,KACE,OAAA,EAAS,OAAA,KAAY,MAAA,CAAO,MAAA,CAAO,oBAAA,EAAsB,SAAA;AAAA,KAEnD,2BAAA,GAA8B,UAAA,KAAe,QAAA,aAAqB,UAAU;AAAA,KAE5E,8BAAA;EAAA,SACD,WAAA,EAAa,4BAAA,CAA6B,OAAA;EAAA,SAC1C,KAAA,EAAO,KAAA,CAAM,KAAA,CAAM,GAAA;EAAA,SACnB,QAAA;EAAA,SACA,UAAA;EAAA,SACA,MAAA,GAAS,2BAAA;AAAA;AAAA,cAwCP,6BAAA,wCACX,SAAA,EAAW,SAAA,CAAU,GAAA,EAAK,KAAA,GAC1B,QAAA,UACA,OAAA,EAAS,8BAAA,CAA+B,OAAA,EAAS,GAAA,MAChD,gBAAA,CAAiB,OAAA;AAAA,cAgDP,uBAAA,wCACX,SAAA,EAAW,SAAA,CAAU,GAAA,EAAK,KAAA,GAC1B,OAAA,EAAS,8BAAA,CAA+B,OAAA,EAAS,GAAA,MAChD,UAAA,CAAW,OAAA"}

package/dist/agent.mjs

@@ -0,0 +1,66 @@
+import { Effect } from "effect";
+import * as Schema from "effect/Schema";
+import { ToolError } from "@yolk-sdk/agent/loop";
+import { makeTool } from "@yolk-sdk/agent/tools";
+import { ToolResult } from "@yolk-sdk/agent/protocol";
+//#region src/agent.ts
+const resolveIntegration = (resolver, context) => {
+	if (typeof resolver === "function") return resolver(context);
+	return Effect.succeed(resolver);
+};
+const resolveAccess = (resolver, actionId) => {
+	if (typeof resolver === "function") return resolver(actionId);
+	return resolver ?? "read";
+};
+const unknownToMessage = (error) => {
+	if (error instanceof Error) return error.message;
+	return String(error);
+};
+const failureContent = (failure) => `${failure.code}: ${failure.message}`;
+const successContent = (value) => {
+	if (typeof value === "string") return value;
+	return JSON.stringify(value);
+};
+const toolName = (prefix, actionId) => prefix === void 0 ? actionId : `${prefix}.${actionId}`;
+const makeConnectorToolRegistration = (connector, actionId, options) => {
+	const action = connector.actions.find((item) => item.id === actionId);
+	const name = toolName(options.namePrefix, actionId);
+	return makeTool({
+		name,
+		description: action?.description ?? `Invoke connector action ${actionId}.`,
+		parameters: action?.inputSchema ?? Schema.Unknown,
+		access: resolveAccess(options.access, actionId),
+		invalidParamsMessage: (error) => `Invalid ${name} arguments: ${unknownToMessage(error)}`,
+		execute: ({ call, context, params }) => resolveIntegration(options.integration, context).pipe(Effect.flatMap((integration) => connector.invoke({
+			integration,
+			action: actionId,
+			input: params
+		}).pipe(Effect.provide(options.layer))), Effect.map((result) => {
+			switch (result._tag) {
+				case "Success": return ToolResult.make({
+					toolCallId: call.id,
+					content: successContent(result.value),
+					structuredContent: result.value
+				});
+				case "Failure": return ToolResult.make({
+					toolCallId: call.id,
+					content: failureContent(result.error),
+					isError: true,
+					structuredContent: result.error
+				});
+			}
+		}), Effect.mapError((error) => new ToolError({
+			tool: name,
+			message: unknownToMessage(error),
+			cause: "execution"
+		})))
+	});
+};
+const makeConnectorToolModule = (connector, options) => ({
+	id: options.moduleId ?? connector.id,
+	tools: connector.actions.map((action) => makeConnectorToolRegistration(connector, action.id, options))
+});
+//#endregion
+export { makeConnectorToolModule, makeConnectorToolRegistration };
+
+//# sourceMappingURL=agent.mjs.map

package/dist/agent.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent.mjs","names":[],"sources":["../src/agent.ts"],"sourcesContent":["import { Effect } from 'effect'\nimport type { Layer } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { ToolError } from '@yolk-sdk/agent/loop'\nimport { makeTool, type ToolAccess, type ToolModule, type ToolRegistration } from '@yolk-sdk/agent/tools'\nimport { ToolResult } from '@yolk-sdk/agent/protocol'\nimport type { Connector } from './connector.ts'\nimport type { ConnectorIntegration } from './integration.ts'\nimport type { ProviderFailure } from './result.ts'\n\nexport type ConnectorIntegrationResolver<Context> =\n  | ConnectorIntegration\n  | ((context: Context) => Effect.Effect<ConnectorIntegration, ToolError>)\n\nexport type ConnectorToolAccessResolver = ToolAccess | ((actionId: string) => ToolAccess)\n\nexport type MakeConnectorToolModuleOptions<Context, Env> = {\n  readonly integration: ConnectorIntegrationResolver<Context>\n  readonly layer: Layer.Layer<Env>\n  readonly moduleId?: string\n  readonly namePrefix?: string\n  readonly access?: ConnectorToolAccessResolver\n}\n\nconst resolveIntegration = <Context>(resolver: ConnectorIntegrationResolver<Context>, context: Context) => {\n  if (typeof resolver === 'function') {\n    return resolver(context)\n  }\n\n  return Effect.succeed(resolver)\n}\n\nconst resolveAccess = (resolver: ConnectorToolAccessResolver | undefined, actionId: string): ToolAccess => {\n  if (typeof resolver === 'function') {\n    return resolver(actionId)\n  }\n\n  return resolver ?? 'read'\n}\n\nconst unknownToMessage = (error: unknown) => {\n  if (error instanceof Error) {\n    return error.message\n  }\n\n  return String(error)\n}\n\nconst failureContent = (failure: ProviderFailure) => `${failure.code}: ${failure.message}`\n\nconst successContent = (value: unknown) => {\n  if (typeof value === 'string') {\n    return value\n  }\n\n  return JSON.stringify(value)\n}\n\nconst toolName = (prefix: string | undefined, actionId: string) =>\n  prefix === undefined ? actionId : `${prefix}.${actionId}`\n\nexport const makeConnectorToolRegistration = <Context, Env = never, Error = never>(\n  connector: Connector<Env, Error>,\n  actionId: string,\n  options: MakeConnectorToolModuleOptions<Context, Env>\n): ToolRegistration<Context> => {\n  const action = connector.actions.find(item => item.id === actionId)\n  const name = toolName(options.namePrefix, actionId)\n\n  return makeTool({\n    name,\n    description: action?.description ?? `Invoke connector action ${actionId}.`,\n    parameters: action?.inputSchema ?? Schema.Unknown,\n    access: resolveAccess(options.access, actionId),\n    invalidParamsMessage: error => `Invalid ${name} arguments: ${unknownToMessage(error)}`,\n    execute: ({ call, context, params }) =>\n      resolveIntegration(options.integration, context).pipe(\n        Effect.flatMap(integration =>\n          connector.invoke({\n            integration,\n            action: actionId,\n            input: params\n          }).pipe(Effect.provide(options.layer))\n        ),\n        Effect.map(result => {\n          switch (result._tag) {\n            case 'Success':\n              return ToolResult.make({\n                toolCallId: call.id,\n                content: successContent(result.value),\n                structuredContent: result.value\n              })\n            case 'Failure':\n              return ToolResult.make({\n                toolCallId: call.id,\n                content: failureContent(result.error),\n                isError: true,\n                structuredContent: result.error\n              })\n          }\n        }),\n        Effect.mapError(\n          error =>\n            new ToolError({\n              tool: name,\n              message: unknownToMessage(error),\n              cause: 'execution'\n            })\n        )\n      )\n  })\n}\n\nexport const makeConnectorToolModule = <Context, Env = never, Error = never>(\n  connector: Connector<Env, Error>,\n  options: MakeConnectorToolModuleOptions<Context, Env>\n): ToolModule<Context> => ({\n  id: options.moduleId ?? connector.id,\n  tools: connector.actions.map(action => makeConnectorToolRegistration(connector, action.id, options))\n})\n"],"mappings":";;;;;;AAwBA,MAAM,sBAA+B,UAAiD,YAAqB;CACzG,IAAI,OAAO,aAAa,YACtB,OAAO,SAAS,OAAO;CAGzB,OAAO,OAAO,QAAQ,QAAQ;AAChC;AAEA,MAAM,iBAAiB,UAAmD,aAAiC;CACzG,IAAI,OAAO,aAAa,YACtB,OAAO,SAAS,QAAQ;CAG1B,OAAO,YAAY;AACrB;AAEA,MAAM,oBAAoB,UAAmB;CAC3C,IAAI,iBAAiB,OACnB,OAAO,MAAM;CAGf,OAAO,OAAO,KAAK;AACrB;AAEA,MAAM,kBAAkB,YAA6B,GAAG,QAAQ,KAAK,IAAI,QAAQ;AAEjF,MAAM,kBAAkB,UAAmB;CACzC,IAAI,OAAO,UAAU,UACnB,OAAO;CAGT,OAAO,KAAK,UAAU,KAAK;AAC7B;AAEA,MAAM,YAAY,QAA4B,aAC5C,WAAW,KAAA,IAAY,WAAW,GAAG,OAAO,GAAG;AAEjD,MAAa,iCACX,WACA,UACA,YAC8B;CAC9B,MAAM,SAAS,UAAU,QAAQ,MAAK,SAAQ,KAAK,OAAO,QAAQ;CAClE,MAAM,OAAO,SAAS,QAAQ,YAAY,QAAQ;CAElD,OAAO,SAAS;EACd;EACA,aAAa,QAAQ,eAAe,2BAA2B,SAAS;EACxE,YAAY,QAAQ,eAAe,OAAO;EAC1C,QAAQ,cAAc,QAAQ,QAAQ,QAAQ;EAC9C,uBAAsB,UAAS,WAAW,KAAK,cAAc,iBAAiB,KAAK;EACnF,UAAU,EAAE,MAAM,SAAS,aACzB,mBAAmB,QAAQ,aAAa,OAAO,EAAE,KAC/C,OAAO,SAAQ,gBACb,UAAU,OAAO;GACf;GACA,QAAQ;GACR,OAAO;EACT,CAAC,EAAE,KAAK,OAAO,QAAQ,QAAQ,KAAK,CAAC,CACvC,GACA,OAAO,KAAI,WAAU;GACnB,QAAQ,OAAO,MAAf;IACE,KAAK,WACH,OAAO,WAAW,KAAK;KACrB,YAAY,KAAK;KACjB,SAAS,eAAe,OAAO,KAAK;KACpC,mBAAmB,OAAO;IAC5B,CAAC;IACH,KAAK,WACH,OAAO,WAAW,KAAK;KACrB,YAAY,KAAK;KACjB,SAAS,eAAe,OAAO,KAAK;KACpC,SAAS;KACT,mBAAmB,OAAO;IAC5B,CAAC;GACL;EACF,CAAC,GACD,OAAO,UACL,UACE,IAAI,UAAU;GACZ,MAAM;GACN,SAAS,iBAAiB,KAAK;GAC/B,OAAO;EACT,CAAC,CACL,CACF;CACJ,CAAC;AACH;AAEA,MAAa,2BACX,WACA,aACyB;CACzB,IAAI,QAAQ,YAAY,UAAU;CAClC,OAAO,UAAU,QAAQ,KAAI,WAAU,8BAA8B,WAAW,OAAO,IAAI,OAAO,CAAC;AACrG"}

package/dist/config.d.mts

@@ -0,0 +1,10 @@
+import { ConnectorError } from "./error.mjs";
+import { ConnectorIntegration } from "./integration.mjs";
+import { Effect } from "effect";
+
+//#region src/config.d.ts
+declare const requiredStringConfig: (integration: ConnectorIntegration, key: string) => Effect.Effect<string, never, never> | Effect.Effect<never, ConnectorError, never>;
+declare const optionalStringConfig: (integration: ConnectorIntegration, key: string) => string | undefined;
+//#endregion
+export { optionalStringConfig, requiredStringConfig };
+//# sourceMappingURL=config.d.mts.map

package/dist/config.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.mts","names":[],"sources":["../src/config.ts"],"mappings":";;;;;cAOa,oBAAA,GAAwB,WAAA,EAAa,oBAAA,EAAsB,GAAA,aAAW,MAAA,CAAA,MAAA,yBAAA,MAAA,CAAA,MAAA,QAAA,cAAA;AAAA,cAgBtE,oBAAA,GAAwB,WAAA,EAAa,oBAAoB,EAAE,GAAA"}

package/dist/config.mjs

@@ -0,0 +1,21 @@
+import { ConnectorError } from "./error.mjs";
+import { Effect } from "effect";
+//#region src/config.ts
+const configValue = (integration, key) => Object.getOwnPropertyDescriptor(integration.config, key)?.value;
+const requiredStringConfig = (integration, key) => {
+	const value = configValue(integration, key);
+	if (typeof value === "string" && value.trim() !== "") return Effect.succeed(value);
+	return Effect.fail(new ConnectorError({
+		cause: "validation_failed",
+		message: `Missing integration config: ${key}`,
+		connectorId: integration.connectorId
+	}));
+};
+const optionalStringConfig = (integration, key) => {
+	const value = configValue(integration, key);
+	return typeof value === "string" && value.trim() !== "" ? value : void 0;
+};
+//#endregion
+export { optionalStringConfig, requiredStringConfig };
+
+//# sourceMappingURL=config.mjs.map

package/dist/config.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.mjs","names":[],"sources":["../src/config.ts"],"sourcesContent":["import { Effect } from 'effect'\nimport { ConnectorError } from './error.ts'\nimport type { ConnectorIntegration } from './integration.ts'\n\nconst configValue = (integration: ConnectorIntegration, key: string) =>\n  Object.getOwnPropertyDescriptor(integration.config, key)?.value\n\nexport const requiredStringConfig = (integration: ConnectorIntegration, key: string) => {\n  const value = configValue(integration, key)\n\n  if (typeof value === 'string' && value.trim() !== '') {\n    return Effect.succeed(value)\n  }\n\n  return Effect.fail(\n    new ConnectorError({\n      cause: 'validation_failed',\n      message: `Missing integration config: ${key}`,\n      connectorId: integration.connectorId\n    })\n  )\n}\n\nexport const optionalStringConfig = (integration: ConnectorIntegration, key: string) => {\n  const value = configValue(integration, key)\n\n  return typeof value === 'string' && value.trim() !== '' ? value : undefined\n}\n"],"mappings":";;;AAIA,MAAM,eAAe,aAAmC,QACtD,OAAO,yBAAyB,YAAY,QAAQ,GAAG,GAAG;AAE5D,MAAa,wBAAwB,aAAmC,QAAgB;CACtF,MAAM,QAAQ,YAAY,aAAa,GAAG;CAE1C,IAAI,OAAO,UAAU,YAAY,MAAM,KAAK,MAAM,IAChD,OAAO,OAAO,QAAQ,KAAK;CAG7B,OAAO,OAAO,KACZ,IAAI,eAAe;EACjB,OAAO;EACP,SAAS,+BAA+B;EACxC,aAAa,YAAY;CAC3B,CAAC,CACH;AACF;AAEA,MAAa,wBAAwB,aAAmC,QAAgB;CACtF,MAAM,QAAQ,YAAY,aAAa,GAAG;CAE1C,OAAO,OAAO,UAAU,YAAY,MAAM,KAAK,MAAM,KAAK,QAAQ,KAAA;AACpE"}

package/dist/connector.d.mts

@@ -0,0 +1,27 @@
+import { ConnectorError } from "./error.mjs";
+import { ActionResult } from "./result.mjs";
+import { ConnectorIntegration } from "./integration.mjs";
+import { ConnectorAction } from "./action.mjs";
+import { Effect } from "effect";
+
+//#region src/connector.d.ts
+type ConnectorInvokeInput = {
+  readonly integration: ConnectorIntegration;
+  readonly action: string;
+  readonly input: unknown;
+};
+type Connector<Env = never, Error = never> = {
+  readonly id: string;
+  readonly description?: string;
+  readonly actions: ReadonlyArray<ConnectorAction<Env, Error>>;
+  readonly invoke: (input: ConnectorInvokeInput) => Effect.Effect<ActionResult<unknown>, Error | ConnectorError, Env>;
+};
+type DefineConnectorOptions<Env, Error> = {
+  readonly id: string;
+  readonly description?: string;
+  readonly actions: ReadonlyArray<ConnectorAction<Env, Error>>;
+};
+declare const defineConnector: <Env = never, Error = never>(options: DefineConnectorOptions<Env, Error>) => Connector<Env, Error>;
+//#endregion
+export { Connector, ConnectorInvokeInput, DefineConnectorOptions, defineConnector };
+//# sourceMappingURL=connector.d.mts.map

package/dist/connector.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector.d.mts","names":[],"sources":["../src/connector.ts"],"mappings":";;;;;;;KAMY,oBAAA;EAAA,SACD,WAAA,EAAa,oBAAoB;EAAA,SACjC,MAAA;EAAA,SACA,KAAA;AAAA;AAAA,KAGC,SAAA;EAAA,SACD,EAAA;EAAA,SACA,WAAA;EAAA,SACA,OAAA,EAAS,aAAA,CAAc,eAAA,CAAgB,GAAA,EAAK,KAAA;EAAA,SAC5C,MAAA,GACP,KAAA,EAAO,oBAAA,KACJ,MAAA,CAAO,MAAA,CAAO,YAAA,WAAuB,KAAA,GAAQ,cAAA,EAAgB,GAAA;AAAA;AAAA,KAGxD,sBAAA;EAAA,SACD,EAAA;EAAA,SACA,WAAA;EAAA,SACA,OAAA,EAAS,aAAA,CAAc,eAAA,CAAgB,GAAA,EAAK,KAAA;AAAA;AAAA,cAkB1C,eAAA,+BACX,OAAA,EAAS,sBAAA,CAAuB,GAAA,EAAK,KAAA,MACpC,SAAA,CAAU,GAAA,EAAK,KAAA"}

package/dist/connector.mjs

@@ -0,0 +1,32 @@
+import { ConnectorError } from "./error.mjs";
+import { Effect, Option } from "effect";
+//#region src/connector.ts
+const connectorMismatchError = (connectorId, integration) => new ConnectorError({
+	cause: "connector_mismatch",
+	message: `Integration belongs to ${integration.connectorId}, not ${connectorId}`,
+	connectorId
+});
+const missingActionError = (connectorId, actionId) => new ConnectorError({
+	cause: "action_not_found",
+	message: `Connector action is not configured: ${actionId}`,
+	connectorId,
+	actionId
+});
+const defineConnector = (options) => ({
+	id: options.id,
+	description: options.description,
+	actions: options.actions,
+	invoke: (input) => {
+		if (input.integration.connectorId !== options.id) return Effect.fail(connectorMismatchError(options.id, input.integration));
+		const action = Option.fromNullishOr(options.actions.find((item) => item.id === input.action));
+		if (Option.isNone(action)) return Effect.fail(missingActionError(options.id, input.action));
+		return action.value.execute({
+			integration: input.integration,
+			input: input.input
+		});
+	}
+});
+//#endregion
+export { defineConnector };
+
+//# sourceMappingURL=connector.mjs.map

package/dist/connector.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connector.mjs","names":[],"sources":["../src/connector.ts"],"sourcesContent":["import { Effect, Option } from 'effect'\nimport type { ConnectorAction } from './action.ts'\nimport { ConnectorError } from './error.ts'\nimport type { ActionResult } from './result.ts'\nimport type { ConnectorIntegration } from './integration.ts'\n\nexport type ConnectorInvokeInput = {\n  readonly integration: ConnectorIntegration\n  readonly action: string\n  readonly input: unknown\n}\n\nexport type Connector<Env = never, Error = never> = {\n  readonly id: string\n  readonly description?: string\n  readonly actions: ReadonlyArray<ConnectorAction<Env, Error>>\n  readonly invoke: (\n    input: ConnectorInvokeInput\n  ) => Effect.Effect<ActionResult<unknown>, Error | ConnectorError, Env>\n}\n\nexport type DefineConnectorOptions<Env, Error> = {\n  readonly id: string\n  readonly description?: string\n  readonly actions: ReadonlyArray<ConnectorAction<Env, Error>>\n}\n\nconst connectorMismatchError = (connectorId: string, integration: ConnectorIntegration) =>\n  new ConnectorError({\n    cause: 'connector_mismatch',\n    message: `Integration belongs to ${integration.connectorId}, not ${connectorId}`,\n    connectorId\n  })\n\nconst missingActionError = (connectorId: string, actionId: string) =>\n  new ConnectorError({\n    cause: 'action_not_found',\n    message: `Connector action is not configured: ${actionId}`,\n    connectorId,\n    actionId\n  })\n\nexport const defineConnector = <Env = never, Error = never>(\n  options: DefineConnectorOptions<Env, Error>\n): Connector<Env, Error> => ({\n  id: options.id,\n  description: options.description,\n  actions: options.actions,\n  invoke: input => {\n    if (input.integration.connectorId !== options.id) {\n      return Effect.fail(connectorMismatchError(options.id, input.integration))\n    }\n\n    const action = Option.fromNullishOr(options.actions.find(item => item.id === input.action))\n\n    if (Option.isNone(action)) {\n      return Effect.fail(missingActionError(options.id, input.action))\n    }\n\n    return action.value.execute({ integration: input.integration, input: input.input })\n  }\n})\n"],"mappings":";;;AA2BA,MAAM,0BAA0B,aAAqB,gBACnD,IAAI,eAAe;CACjB,OAAO;CACP,SAAS,0BAA0B,YAAY,YAAY,QAAQ;CACnE;AACF,CAAC;AAEH,MAAM,sBAAsB,aAAqB,aAC/C,IAAI,eAAe;CACjB,OAAO;CACP,SAAS,uCAAuC;CAChD;CACA;AACF,CAAC;AAEH,MAAa,mBACX,aAC2B;CAC3B,IAAI,QAAQ;CACZ,aAAa,QAAQ;CACrB,SAAS,QAAQ;CACjB,SAAQ,UAAS;EACf,IAAI,MAAM,YAAY,gBAAgB,QAAQ,IAC5C,OAAO,OAAO,KAAK,uBAAuB,QAAQ,IAAI,MAAM,WAAW,CAAC;EAG1E,MAAM,SAAS,OAAO,cAAc,QAAQ,QAAQ,MAAK,SAAQ,KAAK,OAAO,MAAM,MAAM,CAAC;EAE1F,IAAI,OAAO,OAAO,MAAM,GACtB,OAAO,OAAO,KAAK,mBAAmB,QAAQ,IAAI,MAAM,MAAM,CAAC;EAGjE,OAAO,OAAO,MAAM,QAAQ;GAAE,aAAa,MAAM;GAAa,OAAO,MAAM;EAAM,CAAC;CACpF;AACF"}

package/dist/credential.d.mts

@@ -0,0 +1,62 @@
+import { ConnectorError } from "./error.mjs";
+import { ConnectorIntegration } from "./integration.mjs";
+import { Context, Effect, Option } from "effect";
+import * as Schema from "effect/Schema";
+
+//#region src/credential.d.ts
+declare const CredentialKind: Schema.Literals<readonly ["api_key", "bearer_token", "oauth"]>;
+type CredentialKind = typeof CredentialKind.Type;
+declare const CredentialSlot_base: Schema.Class<CredentialSlot, Schema.Struct<{
+  readonly id: Schema.String;
+  readonly kind: Schema.Literals<readonly ["api_key", "bearer_token", "oauth"]>;
+  readonly requiredScopes: Schema.optional<Schema.$Array<Schema.String>>;
+}>, {}>;
+declare class CredentialSlot extends CredentialSlot_base {}
+declare const CredentialBinding_base: Schema.Class<CredentialBinding, Schema.Struct<{
+  readonly slotId: Schema.String;
+  readonly credentialRef: Schema.String;
+  readonly metadata: Schema.optional<Schema.$Record<Schema.String, Schema.Unknown>>;
+}>, {}>;
+declare class CredentialBinding extends CredentialBinding_base {}
+declare const ApiKeyCredential_base: Schema.Class<ApiKeyCredential, Schema.Struct<{
+  readonly _tag: Schema.Literal<"ApiKeyCredential">;
+  readonly key: Schema.String;
+}>, {}>;
+declare class ApiKeyCredential extends ApiKeyCredential_base {}
+declare const BearerTokenCredential_base: Schema.Class<BearerTokenCredential, Schema.Struct<{
+  readonly _tag: Schema.Literal<"BearerTokenCredential">;
+  readonly token: Schema.String;
+  readonly expiresAt: Schema.optional<Schema.Number>;
+}>, {}>;
+declare class BearerTokenCredential extends BearerTokenCredential_base {}
+declare const OAuthCredential_base: Schema.Class<OAuthCredential, Schema.Struct<{
+  readonly _tag: Schema.Literal<"OAuthCredential">;
+  readonly provider: Schema.String;
+  readonly accessToken: Schema.String;
+  readonly expiresAt: Schema.Number;
+  readonly accountId: Schema.optional<Schema.String>;
+  readonly scopes: Schema.optional<Schema.$Array<Schema.String>>;
+}>, {}>;
+declare class OAuthCredential extends OAuthCredential_base {}
+declare const RuntimeCredential: Schema.Union<readonly [typeof ApiKeyCredential, typeof BearerTokenCredential, typeof OAuthCredential]>;
+type RuntimeCredential = typeof RuntimeCredential.Type;
+type CredentialResolveRequest = {
+  readonly integration: ConnectorIntegration;
+  readonly slot: CredentialSlot;
+  readonly binding: CredentialBinding;
+};
+type CredentialResolverApi = {
+  readonly resolve: (request: CredentialResolveRequest) => Effect.Effect<RuntimeCredential, ConnectorError>;
+};
+declare const CredentialResolver_base: Context.ServiceClass<CredentialResolver, "@yolk-sdk/connectors/CredentialResolver", CredentialResolverApi>;
+declare class CredentialResolver extends CredentialResolver_base {}
+declare const makeCredentialBinding: (input: {
+  readonly slotId: string;
+  readonly credentialRef: string;
+  readonly metadata?: Readonly<Record<string, unknown>>;
+}) => CredentialBinding;
+declare const findCredentialBinding: (integration: ConnectorIntegration, slot: CredentialSlot) => Option.Option<CredentialBinding>;
+declare const resolveCredential: (integration: ConnectorIntegration, slot: CredentialSlot) => Effect.Effect<ApiKeyCredential | BearerTokenCredential | OAuthCredential, ConnectorError, CredentialResolver>;
+//#endregion
+export { ApiKeyCredential, BearerTokenCredential, CredentialBinding, CredentialKind, CredentialResolveRequest, CredentialResolver, CredentialResolverApi, CredentialSlot, OAuthCredential, RuntimeCredential, findCredentialBinding, makeCredentialBinding, resolveCredential };
+//# sourceMappingURL=credential.d.mts.map

package/dist/credential.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"credential.d.mts","names":[],"sources":["../src/credential.ts"],"mappings":";;;;;;cAKa,cAAA,EAAc,MAAA,CAAA,QAAA;AAAA,KACf,cAAA,UAAwB,cAAA,CAAe,IAAI;AAAA,cAAA,mBAAA;;;;;cAE1C,cAAA,SAAuB,mBAIlC;AAAA,cAAG,sBAAA;;;;;cAEQ,iBAAA,SAA0B,sBAIrC;AAAA,cAAG,qBAAA;;;;cAEQ,gBAAA,SAAyB,qBAGpC;AAAA,cAAG,0BAAA;;;;;cAEQ,qBAAA,SAA8B,0BAIzC;AAAA,cAAG,oBAAA;;;;;;;;cAEQ,eAAA,SAAwB,oBAOnC;AAAA,cAEW,iBAAA,EAAiB,MAAA,CAAA,KAAA,kBAAA,gBAAA,SAAA,qBAAA,SAAA,eAAA;AAAA,KAClB,iBAAA,UAA2B,iBAAA,CAAkB,IAAI;AAAA,KAEjD,wBAAA;EAAA,SACD,WAAA,EAAa,oBAAA;EAAA,SACb,IAAA,EAAM,cAAA;EAAA,SACN,OAAA,EAAS,iBAAA;AAAA;AAAA,KAGR,qBAAA;EAAA,SACD,OAAA,GACP,OAAA,EAAS,wBAAA,KACN,MAAA,CAAO,MAAA,CAAO,iBAAA,EAAmB,cAAA;AAAA;AAAA,cACvC,uBAAA;cAEY,kBAAA,SAA2B,uBAEvC;AAAA,cAEY,qBAAA,GAAyB,KAAA;EAAA,SAC3B,MAAA;EAAA,SACA,aAAA;EAAA,SACA,QAAA,GAAW,QAAA,CAAS,MAAA;AAAA,MAC9B,iBAAA;AAAA,cAEY,qBAAA,GAAyB,WAAA,EAAa,oBAAA,EAAsB,IAAA,EAAM,cAAA,KAAc,MAAA,CAAA,MAAA,CAAA,iBAAA;AAAA,cAGhF,iBAAA,GAAqB,WAAA,EAAa,oBAAA,EAAsB,IAAA,EAAM,cAAA,KAAc,MAAA,CAAA,MAAA,CAAA,gBAAA,GAAA,qBAAA,GAAA,eAAA,EAAA,cAAA,EAAA,kBAAA"}

package/dist/credential.mjs

@@ -0,0 +1,62 @@
+import { ConnectorError } from "./error.mjs";
+import { Context, Effect, Option } from "effect";
+import * as Schema from "effect/Schema";
+//#region src/credential.ts
+const CredentialKind = Schema.Literals([
+	"api_key",
+	"bearer_token",
+	"oauth"
+]);
+var CredentialSlot = class extends Schema.Class("CredentialSlot")({
+	id: Schema.String,
+	kind: CredentialKind,
+	requiredScopes: Schema.optional(Schema.Array(Schema.String))
+}) {};
+var CredentialBinding = class extends Schema.Class("CredentialBinding")({
+	slotId: Schema.String,
+	credentialRef: Schema.String,
+	metadata: Schema.optional(Schema.Record(Schema.String, Schema.Unknown))
+}) {};
+var ApiKeyCredential = class extends Schema.Class("ApiKeyCredential")({
+	_tag: Schema.Literal("ApiKeyCredential"),
+	key: Schema.String
+}) {};
+var BearerTokenCredential = class extends Schema.Class("BearerTokenCredential")({
+	_tag: Schema.Literal("BearerTokenCredential"),
+	token: Schema.String,
+	expiresAt: Schema.optional(Schema.Number)
+}) {};
+var OAuthCredential = class extends Schema.Class("OAuthCredential")({
+	_tag: Schema.Literal("OAuthCredential"),
+	provider: Schema.String,
+	accessToken: Schema.String,
+	expiresAt: Schema.Number,
+	accountId: Schema.optional(Schema.String),
+	scopes: Schema.optional(Schema.Array(Schema.String))
+}) {};
+const RuntimeCredential = Schema.Union([
+	ApiKeyCredential,
+	BearerTokenCredential,
+	OAuthCredential
+]);
+var CredentialResolver = class extends Context.Service()("@yolk-sdk/connectors/CredentialResolver") {};
+const makeCredentialBinding = (input) => CredentialBinding.make(input);
+const findCredentialBinding = (integration, slot) => Option.fromNullishOr(integration.credentialBindings.find((binding) => binding.slotId === slot.id));
+const resolveCredential = (integration, slot) => Effect.gen(function* () {
+	const binding = findCredentialBinding(integration, slot);
+	if (Option.isNone(binding)) return yield* Effect.fail(new ConnectorError({
+		cause: "credential_binding_missing",
+		message: `Missing credential binding for slot: ${slot.id}`,
+		connectorId: integration.connectorId,
+		slotId: slot.id
+	}));
+	return yield* (yield* CredentialResolver).resolve({
+		integration,
+		slot,
+		binding: binding.value
+	});
+});
+//#endregion
+export { ApiKeyCredential, BearerTokenCredential, CredentialBinding, CredentialKind, CredentialResolver, CredentialSlot, OAuthCredential, RuntimeCredential, findCredentialBinding, makeCredentialBinding, resolveCredential };
+
+//# sourceMappingURL=credential.mjs.map