@dual-os/sdk 0.0.0-stage → 0.8.0-next.0

package/dist/PluginRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginRuntime.d.ts","names":["_$__AgentChannel_ts0.ChannelError","DualRuntime.AuthMethodExecutionError","DualRuntime.InvokeError","DualRuntime.Service","OAuthFlow.Service"],"sources":["../src/PluginRuntime.ts"],"mappings":"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"}

package/dist/PluginRuntime.js

@@ -0,0 +1,331 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import { JsonRequest } from "./AuthMethodExecution.js";
+import { Service } from "./DualRuntime.js";
+import { OAuthGrantRejected, Service as Service$1 } from "./OAuthFlow.js";
+import { Identity, Request as Request$1, Response, execute as execute$1, failure } from "./remote-runtime.js";
+import "./PluginRuntime.js";
+import { Cause, Effect, Queue, Redacted, Schema, Stream, pipe } from "effect";
+import { HttpClientRequest } from "effect/http";
+//#region src/PluginRuntime.ts
+var PluginRuntime_exports = /* @__PURE__ */ __exportAll({
+	AuthRequest: () => AuthRequest,
+	ChannelSettingsRequest: () => ChannelSettingsRequest,
+	ExecutionRequest: () => ExecutionRequest,
+	Input: () => Input,
+	Invocation: () => Invocation,
+	OAuthContinuation: () => OAuthContinuation,
+	OAuthStarted: () => OAuthStarted,
+	Output: () => Output,
+	PluginExecutionError: () => PluginExecutionError,
+	PluginRuntime: () => PluginRuntime_exports,
+	Request: () => Request,
+	SandboxAccessResult: () => SandboxAccessResult,
+	cancellationTimeout: () => cancellationTimeout,
+	checkMessageSize: () => checkMessageSize,
+	decodeInput: () => decodeInput,
+	decodeOutput: () => decodeOutput,
+	encodeInput: () => encodeInput,
+	encodeOutput: () => encodeOutput,
+	encodeRequest: () => encodeRequest,
+	execute: () => execute,
+	ipcMessages: () => ipcMessages,
+	maxChannelResultBytes: () => maxChannelResultBytes,
+	maxMetadataBytes: () => maxMetadataBytes,
+	maxPayloadBytes: () => maxPayloadBytes,
+	readBounded: () => readBounded,
+	responseLimit: () => responseLimit,
+	sendIpc: () => sendIpc,
+	verifyResponse: () => verifyResponse
+});
+var PluginExecutionError = class extends Schema.TaggedError()("PluginExecutionError", {
+	category: Schema.Literals([
+		"transport",
+		"runner",
+		"protocol",
+		"cleanup",
+		"artifact-expired"
+	]),
+	cause: Schema.optionalKey(Schema.Redacted(Schema.Defect())),
+	message: Schema.String
+}) {};
+const maxPayloadBytes = 1048576;
+const maxMetadataBytes = 67108864;
+/** An Agent Channel result carries a read asset of up to 14 MiB. */
+const maxChannelResultBytes = 16777216;
+const cancellationTimeout = "5 seconds";
+/** Receive native Node and Bun IPC messages without interpreting plugin logs. */
+function ipcMessages(channel) {
+	return Stream.callback((queue) => {
+		const message = (value) => {
+			Queue.offerUnsafe(queue, value);
+		};
+		const disconnected = () => {
+			Queue.endUnsafe(queue);
+		};
+		const failed = (cause) => {
+			Queue.failCauseUnsafe(queue, Cause.fail(PluginExecutionError.make({
+				category: "runner",
+				cause: Redacted.make(cause),
+				message: "Plugin IPC channel failed"
+			})));
+		};
+		return Effect.acquireRelease(Effect.sync(() => {
+			channel.on("message", message);
+			channel.on("disconnect", disconnected);
+			channel.on("error", failed);
+		}), () => Effect.sync(() => {
+			channel.removeListener("message", message);
+			channel.removeListener("disconnect", disconnected);
+			channel.removeListener("error", failed);
+		}));
+	});
+}
+/** Queue a JSON message; the runtime reports asynchronous send failures through its error event. */
+function sendIpc(channel, value) {
+	return Effect.try({
+		try: () => {
+			if (!channel.connected || channel.send === void 0) throw PluginExecutionError.make({
+				category: "runner",
+				message: "Plugin IPC channel is closed"
+			});
+			channel.send(value);
+		},
+		catch: (cause) => PluginExecutionError.make({
+			category: "runner",
+			cause: Redacted.make(cause),
+			message: "Cannot send plugin IPC message"
+		})
+	});
+}
+const OAuthContinuation = Schema.Struct({
+	expiresAt: Schema.DateFromString,
+	pkceVerifier: Schema.NullOr(Schema.String),
+	redirectUri: Schema.String,
+	state: Schema.String
+});
+const OAuthStarted = Schema.Struct({
+	authorizationUrl: Schema.String,
+	continuation: OAuthContinuation
+});
+const oauth = {
+	authMethodId: Schema.NonEmptyString,
+	providerId: Schema.NonEmptyString,
+	setup: Schema.optionalKey(Schema.Json)
+};
+const SandboxAccessResult = Schema.Struct({
+	headers: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),
+	origins: Schema.Array(Schema.String)
+});
+const AuthRequest = Schema.TaggedStruct("auth", {
+	identity: Identity,
+	operation: Schema.Union([
+		JsonRequest,
+		Schema.TaggedStruct("oauthStart", {
+			...oauth,
+			redirectUri: Schema.String
+		}),
+		Schema.TaggedStruct("oauthComplete", {
+			...oauth,
+			continuation: OAuthContinuation,
+			query: Schema.Record(Schema.String, Schema.String)
+		}),
+		Schema.TaggedStruct("sandboxAccess", {
+			...oauth,
+			material: Schema.Json,
+			request: Schema.optionalKey(Schema.Struct({
+				headers: Schema.Record(Schema.String, Schema.String),
+				method: Schema.Literals([
+					"GET",
+					"POST",
+					"PUT",
+					"DELETE",
+					"PATCH",
+					"HEAD",
+					"OPTIONS",
+					"TRACE",
+					"QUERY"
+				]),
+				url: Schema.String
+			}))
+		})
+	])
+});
+const ChannelSettingsRequest = Schema.TaggedStruct("channelSettings", {
+	identity: Identity,
+	operation: Schema.TaggedStruct("decodeChannelSettings", {
+		channelId: Schema.NonEmptyString,
+		field: Schema.Literals(["definitionSettings", "deploymentSettings"]),
+		value: Schema.Json
+	})
+});
+const ExecutionRequest = Schema.Union([
+	Request$1,
+	AuthRequest,
+	ChannelSettingsRequest
+]);
+const Request = Schema.Union([ExecutionRequest, Schema.TaggedStruct("extract", { identity: Identity })]);
+const Input = Schema.Union([Request, Schema.TaggedStruct("cancel", { identity: Identity })]);
+const Output = Schema.Union([Response, Schema.TaggedStruct("interrupted", { identity: Identity })]);
+function checkMessageSize(value, maximum) {
+	if (new TextEncoder().encode(JSON.stringify(value)).byteLength <= maximum) return Effect.void;
+	return Effect.fail(PluginExecutionError.make({
+		category: "protocol",
+		message: "Plugin message exceeds its transport limit"
+	}));
+}
+const encodeInput = Effect.fnUntraced(function* (input) {
+	const encoded = yield* Schema.encodeEffect(Input)(input);
+	yield* checkMessageSize(encoded, maxPayloadBytes);
+	return encoded;
+});
+const decodeInput = Effect.fnUntraced(function* (input) {
+	const json = yield* Schema.decodeUnknownEffect(Schema.Json)(input);
+	yield* checkMessageSize(json, maxPayloadBytes);
+	return yield* Schema.decodeUnknownEffect(Input)(json);
+});
+const encodeOutput = Effect.fnUntraced(function* (output, maximum) {
+	const encoded = yield* Schema.encodeEffect(Output)(output);
+	yield* checkMessageSize(encoded, maximum);
+	return encoded;
+});
+const decodeOutput = Effect.fnUntraced(function* (output) {
+	const json = yield* Schema.decodeUnknownEffect(Schema.Json)(output);
+	yield* checkMessageSize(json, maxMetadataBytes);
+	return yield* Schema.decodeUnknownEffect(Output)(json);
+});
+function responseLimit(request) {
+	if ("_tag" in request && request._tag === "extract") return maxMetadataBytes;
+	if ("context" in request && request.operation._tag === "channelExecute") return maxChannelResultBytes;
+	return maxPayloadBytes;
+}
+const Invocation = Schema.Struct({
+	entrypoint: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]+(?:[./][A-Za-z0-9_-]+)*$/u)),
+	exportName: Schema.String.check(Schema.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]*$/u)),
+	request: Request
+});
+const encodeRequest = Effect.fnUntraced(function* (request) {
+	const encoded = yield* pipe(Schema.encodeEffect(Schema.fromJsonString(Request))(request), Effect.mapError((cause) => PluginExecutionError.make({
+		cause: Redacted.make(cause),
+		category: "protocol",
+		message: "Invalid plugin request"
+	})));
+	if (new TextEncoder().encode(encoded).byteLength > 1048576) return yield* PluginExecutionError.make({
+		category: "protocol",
+		message: "Plugin request exceeds the 1 MiB transport limit"
+	});
+	return encoded;
+});
+const readBounded = Effect.fnUntraced(function* (input, maximum = maxPayloadBytes) {
+	const output = {
+		bytes: Buffer.alloc(maximum),
+		size: 0
+	};
+	yield* pipe(input, Stream.runForEach((chunk) => Effect.gen(function* () {
+		if (output.size + chunk.byteLength > maximum) return yield* PluginExecutionError.make({
+			category: "protocol",
+			message: "Plugin payload exceeds its transport limit"
+		});
+		Buffer.from(chunk).copy(output.bytes, output.size);
+		output.size += chunk.byteLength;
+	})), Effect.mapError((cause) => PluginExecutionError.make({
+		cause: Redacted.make(cause),
+		category: "protocol",
+		message: "Cannot read plugin payload"
+	})));
+	return output.bytes.toString("utf8", 0, output.size);
+});
+const verifyResponse = Effect.fnUntraced(function* (request, response) {
+	if (response.identity.invocationId !== request.identity.invocationId || response.identity.artifactDigest !== request.identity.artifactDigest || response.identity.organizationId !== request.identity.organizationId || response.identity.pluginKey !== request.identity.pluginKey || response.identity.pluginVersion !== request.identity.pluginVersion) return yield* PluginExecutionError.make({
+		category: "protocol",
+		message: "Plugin result does not match its invocation"
+	});
+	return response;
+});
+const executeAuth = Effect.fnUntraced(function* (request) {
+	const operation = request.operation;
+	const runtime = yield* Service;
+	if (operation._tag === "sandboxAccess") {
+		const access = yield* runtime.resolveSandboxAccess({
+			...operation,
+			encoding: "json",
+			setup: operation.setup
+		});
+		if (operation.request === void 0) return yield* Schema.encodeEffect(SandboxAccessResult)({ origins: access.origins });
+		const authorized = yield* access.authorize(HttpClientRequest.make(operation.request.method)(operation.request.url, { headers: operation.request.headers }));
+		return yield* Schema.encodeEffect(SandboxAccessResult)({
+			headers: authorized.headers,
+			origins: access.origins
+		});
+	}
+	if (operation._tag !== "oauthStart" && operation._tag !== "oauthComplete") return yield* runtime.executeAuthJson(operation);
+	const method = yield* runtime.getAuthMethod(operation);
+	const setup = yield* runtime.decodeAuthMethodSetup({
+		...operation,
+		encoding: "json",
+		setup: operation.setup
+	});
+	const oauth = yield* Service$1;
+	if (operation._tag === "oauthStart") return yield* Schema.encodeEffect(OAuthStarted)(yield* oauth.start({
+		method,
+		redirectUri: operation.redirectUri,
+		setup
+	}));
+	const completed = yield* oauth.complete({
+		...operation,
+		method,
+		setup
+	});
+	return yield* runtime.executeAuthJson(yield* Schema.decodeUnknownEffect(JsonRequest)({
+		...operation,
+		_tag: "prepareOAuth2Tokens",
+		tokens: completed.tokens
+	}));
+}, (effect, request) => pipe(effect, Effect.flatMap(Effect.fnUntraced(function* (value) {
+	const result = {
+		_tag: "success",
+		identity: request.identity
+	};
+	if (value === void 0) return result;
+	return {
+		...result,
+		value: yield* Schema.decodeUnknownEffect(Schema.Json)(value)
+	};
+})), Effect.catch((error) => {
+	const cause = error._tag === "AuthMethodHookError" ? error.cause : error;
+	return Effect.succeed({
+		_tag: "failure",
+		error: {
+			...failure(error),
+			...Schema.is(OAuthGrantRejected)(cause) ? { code: "OAuthGrantRejected" } : {}
+		},
+		identity: request.identity
+	});
+})));
+const executeChannelSettings = Effect.fnUntraced(function* (request) {
+	const runtime = yield* Service;
+	const { channelId, field, value } = request.operation;
+	const input = {
+		channelId,
+		value
+	};
+	if (field === "definitionSettings") return yield* runtime.decodeAgentChannelDefinitionSettings(input);
+	return yield* runtime.decodeAgentChannelDeploymentSettings(input);
+}, (effect, request) => pipe(effect, Effect.map((value) => ({
+	_tag: "success",
+	identity: request.identity,
+	value
+})), Effect.catch((error) => Effect.succeed({
+	_tag: "failure",
+	error: failure(error),
+	identity: request.identity
+}))));
+/** Execute one request against the plugin built in this process; only the guest runner calls it in production. */
+const execute = Effect.fnUntraced(function* (request) {
+	if (!("_tag" in request)) return yield* execute$1(request);
+	if (request._tag === "auth") return yield* executeAuth(request);
+	return yield* executeChannelSettings(request);
+});
+//#endregion
+export { AuthRequest, ChannelSettingsRequest, ExecutionRequest, Input, Invocation, OAuthContinuation, OAuthStarted, Output, PluginExecutionError, PluginRuntime_exports as PluginRuntime, PluginRuntime_exports, Request, SandboxAccessResult, cancellationTimeout, checkMessageSize, decodeInput, decodeOutput, encodeInput, encodeOutput, encodeRequest, execute, ipcMessages, maxChannelResultBytes, maxMetadataBytes, maxPayloadBytes, readBounded, responseLimit, sendIpc, verifyResponse };
+
+//# sourceMappingURL=PluginRuntime.js.map

package/dist/PluginRuntime.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"PluginRuntime.js","names":["RemoteRuntime.Identity","AuthMethodExecution.JsonRequest","RemoteRuntime.Request","RemoteRuntime.Response","DualRuntime.Service","OAuthFlow.Service","RemoteRuntime.failure","RemoteRuntime.execute"],"sources":["../src/PluginRuntime.ts"],"sourcesContent":["import { Cause, Effect, Queue, Redacted, Schema, Stream, pipe } from \"effect\";\n\nimport { HttpClientRequest } from \"effect/http\";\n\nimport * as AuthMethodExecution from \"./AuthMethodExecution.ts\";\nimport * as DualRuntime from \"./DualRuntime.ts\";\nimport { OAuthFlow, OAuthGrantRejected } from \"./OAuthFlow.ts\";\nimport { RemoteRuntime } from \"./remote-runtime.ts\";\n\nexport class PluginExecutionError extends Schema.TaggedError<PluginExecutionError>()(\n  \"PluginExecutionError\",\n  {\n    category: Schema.Literals([\"transport\", \"runner\", \"protocol\", \"cleanup\", \"artifact-expired\"]),\n    cause: Schema.optionalKey(Schema.Redacted(Schema.Defect())),\n    message: Schema.String,\n  },\n) {}\n\nexport const maxPayloadBytes = 1024 * 1024;\nexport const maxMetadataBytes = 64 * 1024 * 1024;\n/** An Agent Channel result carries a read asset of up to 14 MiB. */\nexport const maxChannelResultBytes = 16 * 1024 * 1024;\nexport const cancellationTimeout = \"5 seconds\";\n\n/** The listener half of a Node or Bun IPC channel: a process or a child process. */\nexport interface IpcEvents {\n  readonly on: (event: string, listener: (value: unknown) => void) => unknown;\n  readonly removeListener: (event: string, listener: (value: unknown) => void) => unknown;\n}\n\n/** The sending half of a Node or Bun IPC channel: a process or a child process. */\nexport interface IpcSender {\n  readonly connected: boolean;\n  readonly send?: ((message: object) => unknown) | undefined;\n}\n\n/** Receive native Node and Bun IPC messages without interpreting plugin logs. */\nexport function ipcMessages(channel: IpcEvents) {\n  return Stream.callback<unknown, PluginExecutionError>(queue => {\n    const message = (value: unknown) => {\n      Queue.offerUnsafe(queue, value);\n    };\n    const disconnected = () => {\n      Queue.endUnsafe(queue);\n    };\n    const failed = (cause: unknown) => {\n      Queue.failCauseUnsafe(\n        queue,\n        Cause.fail(\n          PluginExecutionError.make({\n            category: \"runner\",\n            cause: Redacted.make(cause),\n            message: \"Plugin IPC channel failed\",\n          }),\n        ),\n      );\n    };\n    return Effect.acquireRelease(\n      Effect.sync(() => {\n        channel.on(\"message\", message);\n        channel.on(\"disconnect\", disconnected);\n        channel.on(\"error\", failed);\n      }),\n      () =>\n        Effect.sync(() => {\n          channel.removeListener(\"message\", message);\n          channel.removeListener(\"disconnect\", disconnected);\n          channel.removeListener(\"error\", failed);\n        }),\n    );\n  });\n}\n\n/** Queue a JSON message; the runtime reports asynchronous send failures through its error event. */\nexport function sendIpc(channel: IpcSender, value: object) {\n  return Effect.try({\n    try: () => {\n      if (!channel.connected || channel.send === undefined) {\n        throw PluginExecutionError.make({\n          category: \"runner\",\n          message: \"Plugin IPC channel is closed\",\n        });\n      }\n      channel.send(value);\n    },\n    catch: cause =>\n      PluginExecutionError.make({\n        category: \"runner\",\n        cause: Redacted.make(cause),\n        message: \"Cannot send plugin IPC message\",\n      }),\n  });\n}\n\nexport type OAuthContinuation = typeof OAuthContinuation.Type;\nexport const OAuthContinuation = Schema.Struct({\n  expiresAt: Schema.DateFromString,\n  pkceVerifier: Schema.NullOr(Schema.String),\n  redirectUri: Schema.String,\n  state: Schema.String,\n});\n\nexport type OAuthStarted = typeof OAuthStarted.Type;\nexport const OAuthStarted = Schema.Struct({\n  authorizationUrl: Schema.String,\n  continuation: OAuthContinuation,\n});\n\nconst oauth = {\n  authMethodId: Schema.NonEmptyString,\n  providerId: Schema.NonEmptyString,\n  setup: Schema.optionalKey(Schema.Json),\n};\n\n/** The origins a Connection's credential may reach from a run sandbox, and the headers one request gets. */\nexport type SandboxAccessResult = typeof SandboxAccessResult.Type;\nexport const SandboxAccessResult = Schema.Struct({\n  headers: Schema.optionalKey(Schema.Record(Schema.String, Schema.String)),\n  origins: Schema.Array(Schema.String),\n});\n\nexport type AuthRequest = typeof AuthRequest.Type;\nexport const AuthRequest = Schema.TaggedStruct(\"auth\", {\n  identity: RemoteRuntime.Identity,\n  operation: Schema.Union([\n    AuthMethodExecution.JsonRequest,\n    Schema.TaggedStruct(\"oauthStart\", { ...oauth, redirectUri: Schema.String }),\n    Schema.TaggedStruct(\"oauthComplete\", {\n      ...oauth,\n      continuation: OAuthContinuation,\n      query: Schema.Record(Schema.String, Schema.String),\n    }),\n    // Without `request`, only the origins; with it, the headers the plugin adds to that request.\n    Schema.TaggedStruct(\"sandboxAccess\", {\n      ...oauth,\n      material: Schema.Json,\n      request: Schema.optionalKey(\n        Schema.Struct({\n          headers: Schema.Record(Schema.String, Schema.String),\n          method: Schema.Literals([\n            \"GET\",\n            \"POST\",\n            \"PUT\",\n            \"DELETE\",\n            \"PATCH\",\n            \"HEAD\",\n            \"OPTIONS\",\n            \"TRACE\",\n            \"QUERY\",\n          ]),\n          url: Schema.String,\n        }),\n      ),\n    }),\n  ]),\n});\n\n/** Decode an Agent Channel's settings outside any tenant, as publication validates them. */\nexport type ChannelSettingsRequest = typeof ChannelSettingsRequest.Type;\nexport const ChannelSettingsRequest = Schema.TaggedStruct(\"channelSettings\", {\n  identity: RemoteRuntime.Identity,\n  operation: Schema.TaggedStruct(\"decodeChannelSettings\", {\n    channelId: Schema.NonEmptyString,\n    field: Schema.Literals([\"definitionSettings\", \"deploymentSettings\"]),\n    value: Schema.Json,\n  }),\n});\n\nexport type ExecutionRequest = typeof ExecutionRequest.Type;\nexport const ExecutionRequest = Schema.Union([\n  RemoteRuntime.Request,\n  AuthRequest,\n  ChannelSettingsRequest,\n]);\n\nexport type Request = typeof Request.Type;\nexport const Request = Schema.Union([\n  ExecutionRequest,\n  Schema.TaggedStruct(\"extract\", { identity: RemoteRuntime.Identity }),\n]);\n\nexport type Input = typeof Input.Type;\nexport const Input = Schema.Union([\n  Request,\n  Schema.TaggedStruct(\"cancel\", { identity: RemoteRuntime.Identity }),\n]);\n\nexport type Output = typeof Output.Type;\nexport const Output = Schema.Union([\n  RemoteRuntime.Response,\n  Schema.TaggedStruct(\"interrupted\", { identity: RemoteRuntime.Identity }),\n]);\n\nexport function checkMessageSize(value: unknown, maximum: number) {\n  if (new TextEncoder().encode(JSON.stringify(value)).byteLength <= maximum) return Effect.void;\n  return Effect.fail(\n    PluginExecutionError.make({\n      category: \"protocol\",\n      message: \"Plugin message exceeds its transport limit\",\n    }),\n  );\n}\n\nexport const encodeInput = Effect.fnUntraced(function* (input: Input) {\n  const encoded = yield* Schema.encodeEffect(Input)(input);\n  yield* checkMessageSize(encoded, maxPayloadBytes);\n  return encoded;\n});\n\nexport const decodeInput = Effect.fnUntraced(function* (input: unknown) {\n  const json = yield* Schema.decodeUnknownEffect(Schema.Json)(input);\n  yield* checkMessageSize(json, maxPayloadBytes);\n  return yield* Schema.decodeUnknownEffect(Input)(json);\n});\n\nexport const encodeOutput = Effect.fnUntraced(function* (output: Output, maximum: number) {\n  const encoded = yield* Schema.encodeEffect(Output)(output);\n  yield* checkMessageSize(encoded, maximum);\n  return encoded;\n});\n\nexport const decodeOutput = Effect.fnUntraced(function* (output: unknown) {\n  const json = yield* Schema.decodeUnknownEffect(Schema.Json)(output);\n  yield* checkMessageSize(json, maxMetadataBytes);\n  return yield* Schema.decodeUnknownEffect(Output)(json);\n});\n\nexport function responseLimit(request: Request) {\n  if (\"_tag\" in request && request._tag === \"extract\") return maxMetadataBytes;\n  if (\"context\" in request && request.operation._tag === \"channelExecute\") {\n    return maxChannelResultBytes;\n  }\n  return maxPayloadBytes;\n}\n\nexport type Invocation = typeof Invocation.Type;\nexport const Invocation = Schema.Struct({\n  entrypoint: Schema.String.check(Schema.isPattern(/^[A-Za-z0-9_-]+(?:[./][A-Za-z0-9_-]+)*$/u)),\n  exportName: Schema.String.check(Schema.isPattern(/^[A-Za-z_$][A-Za-z0-9_$]*$/u)),\n  request: Request,\n});\n\nexport const encodeRequest = Effect.fnUntraced(function* (request: Request) {\n  const encoded = yield* pipe(\n    Schema.encodeEffect(Schema.fromJsonString(Request))(request),\n    Effect.mapError(cause =>\n      PluginExecutionError.make({\n        cause: Redacted.make(cause),\n        category: \"protocol\",\n        message: \"Invalid plugin request\",\n      }),\n    ),\n  );\n  if (new TextEncoder().encode(encoded).byteLength > maxPayloadBytes) {\n    return yield* PluginExecutionError.make({\n      category: \"protocol\",\n      message: \"Plugin request exceeds the 1 MiB transport limit\",\n    });\n  }\n  return encoded;\n});\n\nexport const readBounded = Effect.fnUntraced(function* <E, R>(\n  input: Stream.Stream<Uint8Array, E, R>,\n  maximum = maxPayloadBytes,\n) {\n  const output = { bytes: Buffer.alloc(maximum), size: 0 };\n  yield* pipe(\n    input,\n    Stream.runForEach(chunk =>\n      Effect.gen(function* () {\n        if (output.size + chunk.byteLength > maximum) {\n          return yield* PluginExecutionError.make({\n            category: \"protocol\",\n            message: \"Plugin payload exceeds its transport limit\",\n          });\n        }\n        Buffer.from(chunk).copy(output.bytes, output.size);\n        output.size += chunk.byteLength;\n      }),\n    ),\n    Effect.mapError(cause =>\n      PluginExecutionError.make({\n        cause: Redacted.make(cause),\n        category: \"protocol\",\n        message: \"Cannot read plugin payload\",\n      }),\n    ),\n  );\n  return output.bytes.toString(\"utf8\", 0, output.size);\n});\n\nexport const verifyResponse = Effect.fnUntraced(function* <Response extends Output>(\n  request: Request,\n  response: Response,\n) {\n  if (\n    response.identity.invocationId !== request.identity.invocationId ||\n    response.identity.artifactDigest !== request.identity.artifactDigest ||\n    response.identity.organizationId !== request.identity.organizationId ||\n    response.identity.pluginKey !== request.identity.pluginKey ||\n    response.identity.pluginVersion !== request.identity.pluginVersion\n  ) {\n    return yield* PluginExecutionError.make({\n      category: \"protocol\",\n      message: \"Plugin result does not match its invocation\",\n    });\n  }\n  return response;\n});\n\nconst executeAuth = Effect.fnUntraced(\n  function* (request: AuthRequest) {\n    const operation = request.operation;\n    const runtime = yield* DualRuntime.Service;\n    if (operation._tag === \"sandboxAccess\") {\n      const access = yield* runtime.resolveSandboxAccess({\n        ...operation,\n        encoding: \"json\",\n        setup: operation.setup,\n      });\n      if (operation.request === undefined) {\n        return yield* Schema.encodeEffect(SandboxAccessResult)({ origins: access.origins });\n      }\n      const authorized = yield* access.authorize(\n        HttpClientRequest.make(operation.request.method)(operation.request.url, {\n          headers: operation.request.headers,\n        }),\n      );\n      return yield* Schema.encodeEffect(SandboxAccessResult)({\n        headers: authorized.headers,\n        origins: access.origins,\n      });\n    }\n    if (operation._tag !== \"oauthStart\" && operation._tag !== \"oauthComplete\") {\n      return yield* runtime.executeAuthJson(operation);\n    }\n    const method = yield* runtime.getAuthMethod(operation);\n    const setup = yield* runtime.decodeAuthMethodSetup({\n      ...operation,\n      encoding: \"json\",\n      setup: operation.setup,\n    });\n    const oauth = yield* OAuthFlow.Service;\n    if (operation._tag === \"oauthStart\") {\n      return yield* Schema.encodeEffect(OAuthStarted)(\n        yield* oauth.start({ method, redirectUri: operation.redirectUri, setup }),\n      );\n    }\n    const completed = yield* oauth.complete({ ...operation, method, setup });\n    return yield* runtime.executeAuthJson(\n      yield* Schema.decodeUnknownEffect(AuthMethodExecution.JsonRequest)({\n        ...operation,\n        _tag: \"prepareOAuth2Tokens\",\n        tokens: completed.tokens,\n      }),\n    );\n  },\n  (effect, request) =>\n    pipe(\n      effect,\n      Effect.flatMap(\n        Effect.fnUntraced(function* (value) {\n          const result = { _tag: \"success\" as const, identity: request.identity };\n          if (value === undefined) return result;\n          return { ...result, value: yield* Schema.decodeUnknownEffect(Schema.Json)(value) };\n        }),\n      ),\n      Effect.catch(error => {\n        const cause = error._tag === \"AuthMethodHookError\" ? error.cause : error;\n        return Effect.succeed({\n          _tag: \"failure\" as const,\n          error: {\n            ...RemoteRuntime.failure(error),\n            ...(Schema.is(OAuthGrantRejected)(cause) ? { code: \"OAuthGrantRejected\" } : {}),\n          },\n          identity: request.identity,\n        });\n      }),\n    ),\n);\n\nconst executeChannelSettings = Effect.fnUntraced(\n  function* (request: ChannelSettingsRequest) {\n    const runtime = yield* DualRuntime.Service;\n    const { channelId, field, value } = request.operation;\n    const input = { channelId, value };\n    if (field === \"definitionSettings\") {\n      return yield* runtime.decodeAgentChannelDefinitionSettings(input);\n    }\n    return yield* runtime.decodeAgentChannelDeploymentSettings(input);\n  },\n  (effect, request) =>\n    pipe(\n      effect,\n      Effect.map(value => ({ _tag: \"success\", identity: request.identity, value }) as const),\n      Effect.catch(error =>\n        Effect.succeed({\n          _tag: \"failure\" as const,\n          error: RemoteRuntime.failure(error),\n          identity: request.identity,\n        }),\n      ),\n    ),\n);\n\n/** Execute one request against the plugin built in this process; only the guest runner calls it in production. */\nexport const execute = Effect.fnUntraced(function* (request: ExecutionRequest) {\n  if (!(\"_tag\" in request)) return yield* RemoteRuntime.execute(request);\n  if (request._tag === \"auth\") return yield* executeAuth(request);\n  return yield* executeChannelSettings(request);\n});\n\nexport * as PluginRuntime from \"./PluginRuntime.ts\";\n"],"mappings":"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"}

package/dist/Runner.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/Runner.js

@@ -0,0 +1,124 @@
+import { materializePlugin } from "./DualRegistry.js";
+import { fromPlugin, toLayer } from "./DualRuntime.js";
+import { layer, oauth2TokenRefresherLayer } from "./OAuthFlow.js";
+import { isPlugin, make } from "./Plugin.js";
+import { Identity, filesUnavailable } from "./remote-runtime.js";
+import { PluginExecutionError, decodeInput, encodeOutput, execute, ipcMessages, responseLimit, sendIpc } from "./PluginRuntime.js";
+import { Array, Cause, ConfigProvider, Context, Deferred, Effect, Exit, Fiber, FiberMap, Formatter, Inspectable, Layer, Match, Option, Predicate, Redacted, Schema, Scope, Stdio, Stream, String, pipe } from "effect";
+import { FetchHttpClient } from "effect/http";
+import { NodeRuntime, NodeServices } from "@effect/platform-node";
+//#region src/Runner.ts
+const guestOAuth = pipe(oauth2TokenRefresherLayer, Layer.provideMerge(layer), Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({}))));
+function initializationError(cause) {
+	if (Schema.is(PluginExecutionError)(cause)) return cause;
+	return PluginExecutionError.make({
+		category: "runner",
+		cause: Redacted.make(cause),
+		message: pipe(Match.value(cause), Match.when(Predicate.isString, String.trim), Match.orElse((value) => Formatter.format(Inspectable.toJson(value), {
+			ignoreToString: true,
+			space: 2
+		}))) || "No error details returned by the plugin."
+	});
+}
+pipe(Effect.gen(function* () {
+	const guestServices = yield* Effect.context();
+	const scope = yield* Scope.Scope;
+	const runtimeScope = yield* Scope.fork(scope, "sequential");
+	const failed = yield* Deferred.make();
+	const invocations = yield* FiberMap.make();
+	const stdio = yield* Stdio.Stdio;
+	const args = yield* Schema.decodeUnknownEffect(Schema.Tuple([
+		Schema.NonEmptyString,
+		Schema.NonEmptyString,
+		Schema.Literals(["inspect", "execute"]),
+		Schema.NonEmptyString
+	]))(yield* stdio.args);
+	const load = yield* Effect.cached(Effect.forkIn(Effect.gen(function* () {
+		const plugin = (yield* Schema.decodeUnknownEffect(Schema.Record(Schema.String, Schema.Unknown))(yield* Effect.tryPromise({
+			try: () => import(args[0]),
+			catch: initializationError
+		})))[args[1]];
+		if (!isPlugin(plugin)) return yield* PluginExecutionError.make({
+			category: "protocol",
+			message: "The configured export is not an integration plugin"
+		});
+		yield* Effect.try({
+			try: () => make(plugin.identifier),
+			catch: initializationError
+		});
+		return {
+			plugin,
+			runtime: yield* Effect.cached(Effect.forkIn(pipe(Layer.buildWithScope(pipe(toLayer(fromPlugin(plugin, args[3])), Layer.provideMerge(Layer.mergeAll(filesUnavailable, FetchHttpClient.layer, guestOAuth))), runtimeScope), Effect.provideContext(Context.makeUnsafe(guestServices.mapUnsafe))), runtimeScope))
+		};
+	}), runtimeScope));
+	const execute$1 = Effect.fnUntraced(function* (request) {
+		return yield* pipe(Effect.gen(function* () {
+			const { plugin, runtime } = yield* Fiber.join(yield* load);
+			if (request.identity.pluginKey !== plugin.identifier && !(args[2] === "inspect" && "_tag" in request && request._tag === "extract")) return yield* PluginExecutionError.make({
+				category: "protocol",
+				message: "Plugin identity does not match the request"
+			});
+			if (request.identity.pluginVersion !== args[3]) return yield* PluginExecutionError.make({
+				category: "protocol",
+				message: "Plugin release does not match the request"
+			});
+			if ("_tag" in request && request._tag === "extract") return {
+				_tag: "success",
+				identity: request.identity,
+				value: yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Json))(yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))(materializePlugin(plugin, { version: request.identity.pluginVersion })))
+			};
+			return yield* pipe(execute(request), Effect.provideContext(yield* Fiber.join(yield* runtime)));
+		}), Effect.catchCauseIf((cause) => !Cause.hasInterrupts(cause), (cause) => args[2] === "inspect" ? Effect.fail(initializationError(Cause.squash(cause))) : Effect.succeed({
+			_tag: "failure",
+			identity: request.identity,
+			error: {
+				category: "initialization",
+				code: "PluginInitializationFailed",
+				message: "Cannot initialize the installed plugin",
+				retryable: false
+			}
+		})), Effect.mapError(initializationError));
+	});
+	yield* Effect.raceFirst(pipe(ipcMessages(process), Stream.runForEach(Effect.fnUntraced(function* (message) {
+		const input = yield* decodeInput(message);
+		const key = yield* Schema.encodeEffect(Schema.fromJsonString(Identity))(input.identity);
+		if ("_tag" in input && input._tag === "cancel") {
+			const fiber = Option.getOrUndefined(yield* FiberMap.get(invocations, key));
+			if (fiber !== void 0) yield* pipe(Fiber.interrupt(fiber), Effect.forkIn(scope));
+			return;
+		}
+		if ((yield* FiberMap.has(invocations, key)) || (yield* FiberMap.size(invocations)) >= 16) return yield* PluginExecutionError.make({
+			category: "protocol",
+			message: "Plugin invocation is duplicate or exceeds concurrency"
+		});
+		const fiber = yield* FiberMap.run(invocations, key, Effect.scoped(execute$1(input)));
+		yield* pipe(Effect.gen(function* () {
+			const exit = yield* Fiber.await(fiber);
+			const send = Effect.fnUntraced(function* (output) {
+				const encoded = yield* encodeOutput(output, responseLimit(input));
+				if (args[2] !== "inspect") return yield* sendIpc(process, encoded);
+				yield* Effect.callback((resume) => {
+					if (process.send === void 0) {
+						resume(Effect.fail(initializationError("Plugin IPC channel is closed")));
+						return;
+					}
+					process.send(encoded, (error) => {
+						if (error !== null) resume(Effect.fail(initializationError(error)));
+						else resume(Effect.void);
+					});
+				});
+				if (process.connected) process.disconnect();
+			});
+			if (Exit.isSuccess(exit)) return yield* send(exit.value);
+			if (Array.every(exit.cause.reasons, Cause.isInterruptReason)) return yield* send({
+				_tag: "interrupted",
+				identity: input.identity
+			});
+			return yield* initializationError(Cause.squash(exit.cause));
+		}), Effect.catchCause((cause) => Deferred.fail(failed, initializationError(Cause.squash(cause)))), Effect.forkIn(scope));
+	})), Effect.mapError(initializationError)), Deferred.await(failed));
+}), Effect.scoped, Effect.provide(NodeServices.layer), NodeRuntime.runMain({ disableErrorReporting: process.argv[4] !== "inspect" }));
+//#endregion
+export {};
+
+//# sourceMappingURL=Runner.js.map

package/dist/Runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Runner.js","names":["OAuthFlow.layer","PluginRuntime.PluginExecutionError","Plugin.isPlugin","Plugin.make","DualRuntime.toLayer","DualRuntime.fromPlugin","RemoteRuntime.filesUnavailable","execute","DualRegistry.materializePlugin","PluginRuntime.execute","PluginRuntime.ipcMessages","PluginRuntime.decodeInput","RemoteRuntime.Identity","PluginRuntime.encodeOutput","PluginRuntime.responseLimit","PluginRuntime.sendIpc"],"sources":["../src/Runner.ts"],"sourcesContent":["import { NodeRuntime, NodeServices } from \"@effect/platform-node\";\n\nimport {\n  Array,\n  Cause,\n  ConfigProvider,\n  Context,\n  Deferred,\n  Effect,\n  Exit,\n  Fiber,\n  FiberMap,\n  Formatter,\n  Inspectable,\n  Layer,\n  Match,\n  Option,\n  Predicate,\n  Redacted,\n  Schema,\n  Scope,\n  Stdio,\n  Stream,\n  String,\n  pipe,\n} from \"effect\";\n\nimport { FetchHttpClient } from \"effect/http\";\n\nimport * as DualRegistry from \"./DualRegistry.ts\";\nimport * as DualRuntime from \"./DualRuntime.ts\";\nimport { OAuthFlow, oauth2TokenRefresherLayer } from \"./OAuthFlow.ts\";\nimport * as Plugin from \"./Plugin.ts\";\nimport { PluginRuntime } from \"./PluginRuntime.ts\";\nimport { RemoteRuntime } from \"./remote-runtime.ts\";\n\nconst guestOAuth = pipe(\n  oauth2TokenRefresherLayer,\n  Layer.provideMerge(OAuthFlow.layer),\n  Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({}))),\n);\n\nfunction initializationError(cause: unknown) {\n  // Each hop of the runner maps its failure here; the first error keeps its message.\n  if (Schema.is(PluginRuntime.PluginExecutionError)(cause)) return cause;\n  return PluginRuntime.PluginExecutionError.make({\n    category: \"runner\",\n    cause: Redacted.make(cause),\n    message:\n      pipe(\n        Match.value(cause),\n        Match.when(Predicate.isString, String.trim),\n        Match.orElse(value =>\n          Formatter.format(Inspectable.toJson(value), { ignoreToString: true, space: 2 }),\n        ),\n      ) || \"No error details returned by the plugin.\",\n  });\n}\n\n// This executable runs only in the plugin's process, using its own SDK and Effect.\npipe(\n  Effect.gen(function* () {\n    const guestServices = yield* Effect.context<NodeServices.NodeServices>();\n    const scope = yield* Scope.Scope;\n    const runtimeScope = yield* Scope.fork(scope, \"sequential\");\n    const failed = yield* Deferred.make<never, PluginRuntime.PluginExecutionError>();\n    const invocations = yield* FiberMap.make<\n      string,\n      RemoteRuntime.Response,\n      PluginRuntime.PluginExecutionError\n    >();\n    const stdio = yield* Stdio.Stdio;\n    const args = yield* Schema.decodeUnknownEffect(\n      Schema.Tuple([\n        Schema.NonEmptyString,\n        Schema.NonEmptyString,\n        Schema.Literals([\"inspect\", \"execute\"]),\n        Schema.NonEmptyString,\n      ]),\n    )(yield* stdio.args);\n    const load = yield* Effect.cached(\n      Effect.forkIn(\n        Effect.gen(function* () {\n          const exports = yield* Schema.decodeUnknownEffect(\n            Schema.Record(Schema.String, Schema.Unknown),\n          )(yield* Effect.tryPromise({ try: () => import(args[0]), catch: initializationError }));\n          const plugin = exports[args[1]];\n          if (!Plugin.isPlugin(plugin)) {\n            return yield* PluginRuntime.PluginExecutionError.make({\n              category: \"protocol\",\n              message: \"The configured export is not an integration plugin\",\n            });\n          }\n          yield* Effect.try({\n            try: () => Plugin.make(plugin.identifier),\n            catch: initializationError,\n          });\n          const runtime = yield* Effect.cached(\n            Effect.forkIn(\n              pipe(\n                Layer.buildWithScope(\n                  pipe(\n                    // @effect-diagnostics-next-line anyUnknownInErrorContext:off -- Imported plugin requirements are erased; the guest supplies only its own services.\n                    DualRuntime.toLayer(DualRuntime.fromPlugin(plugin, args[3])),\n                    Layer.provideMerge(\n                      Layer.mergeAll(\n                        RemoteRuntime.filesUnavailable,\n                        FetchHttpClient.layer,\n                        guestOAuth,\n                      ),\n                    ),\n                  ),\n                  runtimeScope,\n                ),\n                Effect.provideContext(Context.makeUnsafe<unknown>(guestServices.mapUnsafe)),\n              ),\n              runtimeScope,\n            ),\n          );\n          return { plugin, runtime };\n        }),\n        runtimeScope,\n      ),\n    );\n    const execute = Effect.fnUntraced(function* (request: PluginRuntime.Request) {\n      return yield* pipe(\n        Effect.gen(function* () {\n          const { plugin, runtime } = yield* Fiber.join(yield* load);\n          if (\n            request.identity.pluginKey !== plugin.identifier &&\n            !(args[2] === \"inspect\" && \"_tag\" in request && request._tag === \"extract\")\n          ) {\n            return yield* PluginRuntime.PluginExecutionError.make({\n              category: \"protocol\",\n              message: \"Plugin identity does not match the request\",\n            });\n          }\n          if (request.identity.pluginVersion !== args[3])\n            return yield* PluginRuntime.PluginExecutionError.make({\n              category: \"protocol\",\n              message: \"Plugin release does not match the request\",\n            });\n          if (\"_tag\" in request && request._tag === \"extract\") {\n            return {\n              _tag: \"success\",\n              identity: request.identity,\n              value: yield* Schema.decodeEffect(Schema.fromJsonString(Schema.Json))(\n                yield* Schema.encodeEffect(Schema.fromJsonString(Schema.Unknown))(\n                  DualRegistry.materializePlugin(plugin, {\n                    version: request.identity.pluginVersion,\n                  }),\n                ),\n              ),\n            } satisfies RemoteRuntime.Response;\n          }\n          return yield* pipe(\n            PluginRuntime.execute(request),\n            Effect.provideContext(yield* Fiber.join(yield* runtime)),\n          );\n        }),\n        Effect.catchCauseIf(\n          cause => !Cause.hasInterrupts(cause),\n          cause =>\n            args[2] === \"inspect\"\n              ? Effect.fail(initializationError(Cause.squash(cause)))\n              : Effect.succeed({\n                  _tag: \"failure\",\n                  identity: request.identity,\n                  error: {\n                    category: \"initialization\",\n                    code: \"PluginInitializationFailed\",\n                    message: \"Cannot initialize the installed plugin\",\n                    retryable: false,\n                  },\n                } satisfies RemoteRuntime.Response),\n        ),\n        Effect.mapError(initializationError),\n      );\n    });\n    yield* Effect.raceFirst(\n      pipe(\n        PluginRuntime.ipcMessages(process),\n        Stream.runForEach(\n          Effect.fnUntraced(function* (message) {\n            const input = yield* PluginRuntime.decodeInput(message);\n            const key = yield* Schema.encodeEffect(Schema.fromJsonString(RemoteRuntime.Identity))(\n              input.identity,\n            );\n            if (\"_tag\" in input && input._tag === \"cancel\") {\n              const fiber = Option.getOrUndefined(yield* FiberMap.get(invocations, key));\n              if (fiber !== undefined) yield* pipe(Fiber.interrupt(fiber), Effect.forkIn(scope));\n              return;\n            }\n            if (\n              (yield* FiberMap.has(invocations, key)) ||\n              (yield* FiberMap.size(invocations)) >= 16\n            ) {\n              return yield* PluginRuntime.PluginExecutionError.make({\n                category: \"protocol\",\n                message: \"Plugin invocation is duplicate or exceeds concurrency\",\n              });\n            }\n            const fiber = yield* FiberMap.run(invocations, key, Effect.scoped(execute(input)));\n            yield* pipe(\n              Effect.gen(function* () {\n                const exit = yield* Fiber.await(fiber);\n                const send = Effect.fnUntraced(function* (output: PluginRuntime.Output) {\n                  const encoded = yield* PluginRuntime.encodeOutput(\n                    output,\n                    PluginRuntime.responseLimit(input),\n                  );\n                  if (args[2] !== \"inspect\") return yield* PluginRuntime.sendIpc(process, encoded);\n                  // Bun can discard queued data on disconnect; wait for its native send callback.\n                  yield* Effect.callback<void, PluginRuntime.PluginExecutionError>(resume => {\n                    if (process.send === undefined) {\n                      resume(Effect.fail(initializationError(\"Plugin IPC channel is closed\")));\n                      return;\n                    }\n                    process.send(encoded, error => {\n                      if (error !== null) resume(Effect.fail(initializationError(error)));\n                      else resume(Effect.void);\n                    });\n                  });\n                  if (process.connected) process.disconnect();\n                });\n                if (Exit.isSuccess(exit)) return yield* send(exit.value);\n                if (Array.every(exit.cause.reasons, Cause.isInterruptReason)) {\n                  return yield* send({ _tag: \"interrupted\", identity: input.identity });\n                }\n                return yield* initializationError(Cause.squash(exit.cause));\n              }),\n              Effect.catchCause(cause =>\n                Deferred.fail(failed, initializationError(Cause.squash(cause))),\n              ),\n              Effect.forkIn(scope),\n            );\n          }),\n        ),\n        Effect.mapError(initializationError),\n      ),\n      Deferred.await(failed),\n    );\n  }),\n  Effect.scoped,\n  // @effect-diagnostics-next-line strictEffectProvide:off -- This executable owns the guest process services.\n  Effect.provide(NodeServices.layer),\n  NodeRuntime.runMain({ disableErrorReporting: process.argv[4] !== \"inspect\" }),\n);\n"],"mappings":"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"}

package/dist/ToolFile.d.ts

@@ -0,0 +1,23 @@
+import "./ToolFile.js";
+import { Schema as Schema$1 } from "effect";
+declare namespace ToolFile_d_exports {
+  export { File, Schema, ToolFile_d_exports as ToolFile };
+}
+/**
+ * Complete file content and metadata. Hosts validate the bytes before saving them;
+ * a filename is a suggestion, never a trusted destination path.
+ *
+ * @since 0.0.0
+ * @category schemas
+ */
+export declare const Schema: Schema$1.TaggedStruct<"ToolFile", {
+  readonly contentBase64: Schema$1.String;
+  readonly contentType: Schema$1.NullOr<Schema$1.String>;
+  readonly filename: Schema$1.NullOr<Schema$1.String>;
+  readonly sizeBytes: Schema$1.Natural;
+}>;
+/** @since 0.0.0 @category models */
+export type File = typeof Schema.Type;
+//#endregion
+export { ToolFile_d_exports as ToolFile, ToolFile_d_exports };
+//# sourceMappingURL=ToolFile.d.ts.map

package/dist/ToolFile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolFile.d.ts","names":["EffectSchema"],"sources":["../src/ToolFile.ts"],"mappings":";;;;;;;;;;;;qBAca,QAAMA,SAAA;;;;;;;YAWP,cAAc,OAAO"}

package/dist/ToolFile.js

@@ -0,0 +1,33 @@
+import { __exportAll } from "./_virtual/_rolldown/runtime.js";
+import "./ToolFile.js";
+import { Schema as Schema$1 } from "effect";
+//#region src/ToolFile.ts
+/**
+* JSON-safe file results that hosts can persist without reconstructing displayed text.
+*
+* @since 0.0.0
+*/
+var ToolFile_exports = /* @__PURE__ */ __exportAll({
+	Schema: () => Schema,
+	ToolFile: () => ToolFile_exports
+});
+/**
+* Complete file content and metadata. Hosts validate the bytes before saving them;
+* a filename is a suggestion, never a trusted destination path.
+*
+* @since 0.0.0
+* @category schemas
+*/
+const Schema = Schema$1.TaggedStruct("ToolFile", {
+	contentBase64: Schema$1.String.annotate({
+		contentEncoding: "base64",
+		description: "Complete file bytes in Base64. Preserve this field without truncation."
+	}),
+	contentType: Schema$1.NullOr(Schema$1.String),
+	filename: Schema$1.NullOr(Schema$1.String),
+	sizeBytes: Schema$1.Natural
+});
+//#endregion
+export { Schema, ToolFile_exports as ToolFile, ToolFile_exports };
+
+//# sourceMappingURL=ToolFile.js.map

package/dist/ToolFile.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ToolFile.js","names":["EffectSchema"],"sources":["../src/ToolFile.ts"],"sourcesContent":["/**\n * JSON-safe file results that hosts can persist without reconstructing displayed text.\n *\n * @since 0.0.0\n */\nimport { Schema as EffectSchema } from \"effect\";\n\n/**\n * Complete file content and metadata. Hosts validate the bytes before saving them;\n * a filename is a suggestion, never a trusted destination path.\n *\n * @since 0.0.0\n * @category schemas\n */\nexport const Schema = EffectSchema.TaggedStruct(\"ToolFile\", {\n  contentBase64: EffectSchema.String.annotate({\n    contentEncoding: \"base64\",\n    description: \"Complete file bytes in Base64. Preserve this field without truncation.\",\n  }),\n  contentType: EffectSchema.NullOr(EffectSchema.String),\n  filename: EffectSchema.NullOr(EffectSchema.String),\n  sizeBytes: EffectSchema.Natural,\n});\n\n/** @since 0.0.0 @category models */\nexport type File = typeof Schema.Type;\n\nexport * as ToolFile from \"./ToolFile.ts\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAcA,MAAa,SAASA,SAAa,aAAa,YAAY;CAC1D,eAAeA,SAAa,OAAO,SAAS;EAC1C,iBAAiB;EACjB,aAAa;CACf,CAAC;CACD,aAAaA,SAAa,OAAOA,SAAa,MAAM;CACpD,UAAUA,SAAa,OAAOA,SAAa,MAAM;CACjD,WAAWA,SAAa;AAC1B,CAAC"}