@yolk-sdk/agent 0.0.1-canary.0

package/dist/tools/registry.mjs

@@ -0,0 +1,113 @@
+import { Array as Array$1, Effect, Layer, Option } from "effect";
+import * as Schema from "effect/Schema";
+import { ToolDef } from "@yolk-sdk/agent/protocol";
+import { ToolError, ToolExecutor } from "@yolk-sdk/agent/loop";
+//#region src/tools/registry.ts
+const ToolAccess = Schema.Literals([
+	"read",
+	"write",
+	"destructive"
+]);
+var ToolRegistryError = class extends Schema.TaggedErrorClass()("ToolRegistryError", {
+	message: Schema.String,
+	cause: Schema.Literals(["duplicate_tool"])
+}) {};
+const EmptyToolParams = Schema.Record(Schema.String, Schema.Never);
+const enabled = (tool, context) => tool.isEnabled === void 0 ? Effect.succeed(true) : tool.isEnabled(context);
+const resolveModuleTools = (toolModule, context) => Effect.forEach(toolModule.tools, (tool) => enabled(tool, context).pipe(Effect.map((isToolEnabled) => isToolEnabled ? Option.some({
+	moduleId: toolModule.id,
+	tool
+}) : Option.none()))).pipe(Effect.map(Array$1.getSomes));
+const duplicateToolError = (name) => new ToolRegistryError({
+	cause: "duplicate_tool",
+	message: `Duplicate tool registered: ${name}`
+});
+const missingToolError = (name) => new ToolError({
+	tool: name,
+	message: `Tool is not configured: ${name}`,
+	cause: "not_found"
+});
+const unknownToMessage = (error) => error instanceof Error ? error.message : String(error);
+const objectField = (input, key) => input !== null && typeof input === "object" ? Object.getOwnPropertyDescriptor(input, key)?.value : void 0;
+const isObjectRecord = (input) => input !== null && typeof input === "object" && !Array.isArray(input);
+const localDefinitionName = (ref) => {
+	if (typeof ref !== "string") return;
+	return ref.startsWith("#/$defs/") ? ref.slice(8) : void 0;
+};
+const hasJsonSchemaType = (input, type) => objectField(input, "type") === type;
+const isEmptyStructJsonSchema = (schema) => {
+	const anyOf = objectField(schema, "anyOf");
+	return Array.isArray(anyOf) && anyOf.length === 2 && anyOf.some((item) => hasJsonSchemaType(item, "object")) && anyOf.some((item) => hasJsonSchemaType(item, "array"));
+};
+const isEmptyRecordJsonSchema = (schema) => hasJsonSchemaType(schema, "object") && objectField(schema, "additionalProperties") === false && objectField(schema, "properties") === void 0 && objectField(schema, "required") === void 0;
+const emptyObjectJsonSchema = {
+	type: "object",
+	properties: {},
+	required: [],
+	additionalProperties: false
+};
+const jsonSchemaFromSchema = (schema) => {
+	const document = Schema.toJsonSchemaDocument(schema);
+	const definitionName = localDefinitionName(objectField(document.schema, "$ref"));
+	const localDefinition = definitionName === void 0 ? void 0 : Object.getOwnPropertyDescriptor(document.definitions, definitionName)?.value;
+	const rootSchema = isObjectRecord(localDefinition) ? localDefinition : document.schema;
+	const remainingDefinitions = definitionName === void 0 ? document.definitions : Object.fromEntries(Object.entries(document.definitions).filter(([name]) => name !== definitionName));
+	const jsonSchema = isEmptyStructJsonSchema(rootSchema) || isEmptyRecordJsonSchema(rootSchema) ? emptyObjectJsonSchema : rootSchema;
+	return Object.keys(remainingDefinitions).length > 0 ? {
+		...jsonSchema,
+		$defs: remainingDefinitions
+	} : jsonSchema;
+};
+const makeTool = (options) => ({
+	def: ToolDef.make({
+		name: options.name,
+		description: options.description,
+		parameters: jsonSchemaFromSchema(options.parameters),
+		approval: options.approval
+	}),
+	access: options.access,
+	approval: options.approval,
+	isEnabled: options.isEnabled,
+	execute: ({ call, context }) => Schema.decodeUnknownEffect(options.parameters)(call.params).pipe(Effect.mapError((error) => new ToolError({
+		tool: options.name,
+		message: options.invalidParamsMessage?.(error) ?? `Invalid ${options.name} arguments: ${unknownToMessage(error)}`,
+		cause: "validation"
+	})), Effect.flatMap((params) => options.execute({
+		call,
+		context,
+		params
+	})))
+});
+const findDuplicateToolName = (resolved) => {
+	const names = Array$1.map(resolved, (item) => item.tool.def.name);
+	return Array$1.findFirst(names, (name, index) => names.indexOf(name) !== index);
+};
+const resolveTools = (modules, context) => Effect.gen(function* () {
+	const resolvedByModule = yield* Effect.forEach(modules, (toolModule) => resolveModuleTools(toolModule, context));
+	const resolved = Array$1.flatten(resolvedByModule);
+	const duplicateName = findDuplicateToolName(resolved);
+	if (Option.isSome(duplicateName)) return yield* Effect.fail(duplicateToolError(duplicateName.value));
+	const tools = Array$1.map(resolved, (item) => item.tool.def);
+	const metadata = Array$1.map(resolved, (item) => ({
+		moduleId: item.moduleId,
+		name: item.tool.def.name,
+		access: item.tool.access
+	}));
+	const execute = (call) => Option.match(Array$1.findFirst(resolved, (item) => item.tool.def.name === call.name), {
+		onNone: () => Effect.fail(missingToolError(call.name)),
+		onSome: (match) => match.tool.execute({
+			call,
+			context
+		})
+	});
+	return {
+		tools,
+		metadata,
+		execute
+	};
+});
+const makeToolExecutorLayer = (toolSet) => Layer.succeed(ToolExecutor, ToolExecutor.of({ execute: toolSet.execute }));
+//#endregion
+export { EmptyToolParams, ToolAccess, ToolRegistryError, makeTool, makeToolExecutorLayer, resolveTools };
+
+//# sourceMappingURL=registry.mjs.map

package/dist/tools/registry.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.mjs","names":["Arr"],"sources":["../../src/tools/registry.ts"],"sourcesContent":["import { Array as Arr, Effect, Layer, Option } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { ToolError, ToolExecutor } from '@yolk-sdk/agent/loop'\nimport { ToolDef, type ToolApprovalPolicy, type ToolCall, type ToolResult } from '@yolk-sdk/agent/protocol'\n\nexport const ToolAccess = Schema.Literals(['read', 'write', 'destructive'])\nexport type ToolAccess = typeof ToolAccess.Type\n\nexport class ToolRegistryError extends Schema.TaggedErrorClass<ToolRegistryError>()(\n  'ToolRegistryError',\n  {\n    message: Schema.String,\n    cause: Schema.Literals(['duplicate_tool'])\n  }\n) {}\n\nexport type ToolExecutionInput<Context> = {\n  readonly call: ToolCall\n  readonly context: Context\n}\n\nexport type SchemaToolExecutionInput<Context, Params> = ToolExecutionInput<Context> & {\n  readonly params: Params\n}\n\nexport type ToolRegistration<Context> = {\n  readonly def: ToolDef\n  readonly access: ToolAccess\n  readonly approval?: ToolApprovalPolicy\n  readonly isEnabled?: (context: Context) => Effect.Effect<boolean, ToolRegistryError>\n  readonly execute: (input: ToolExecutionInput<Context>) => Effect.Effect<ToolResult, ToolError>\n}\n\ntype ToolParamsSchema = Schema.Schema<unknown> & { readonly DecodingServices: never }\n\nexport const EmptyToolParams = Schema.Record(Schema.String, Schema.Never)\n\nexport type MakeToolOptions<Context, ParamsSchema extends ToolParamsSchema> = {\n  readonly name: string\n  readonly description: string\n  readonly parameters: ParamsSchema\n  readonly access: ToolAccess\n  readonly approval?: ToolApprovalPolicy\n  readonly isEnabled?: (context: Context) => Effect.Effect<boolean, ToolRegistryError>\n  readonly invalidParamsMessage?: (error: unknown) => string\n  readonly execute: (\n    input: SchemaToolExecutionInput<Context, ParamsSchema['Type']>\n  ) => Effect.Effect<ToolResult, ToolError>\n}\n\nexport type ToolModule<Context> = {\n  readonly id: string\n  readonly tools: ReadonlyArray<ToolRegistration<Context>>\n}\n\nexport type ToolMetadata = {\n  readonly moduleId: string\n  readonly name: string\n  readonly access: ToolAccess\n}\n\ntype ResolvedRegistration<Context> = {\n  readonly moduleId: string\n  readonly tool: ToolRegistration<Context>\n}\n\nexport type ResolvedToolSet = {\n  readonly tools: ReadonlyArray<ToolDef>\n  readonly metadata: ReadonlyArray<ToolMetadata>\n  readonly execute: (call: ToolCall) => Effect.Effect<ToolResult, ToolError>\n}\n\nconst enabled = <Context>(tool: ToolRegistration<Context>, context: Context) =>\n  tool.isEnabled === undefined ? Effect.succeed(true) : tool.isEnabled(context)\n\nconst resolveModuleTools = <Context>(toolModule: ToolModule<Context>, context: Context) =>\n  Effect.forEach(toolModule.tools, tool =>\n    enabled(tool, context).pipe(\n      Effect.map(isToolEnabled =>\n        isToolEnabled ? Option.some({ moduleId: toolModule.id, tool }) : Option.none()\n      )\n    )\n  ).pipe(Effect.map(Arr.getSomes))\n\nconst duplicateToolError = (name: string) =>\n  new ToolRegistryError({\n    cause: 'duplicate_tool',\n    message: `Duplicate tool registered: ${name}`\n  })\n\nconst missingToolError = (name: string) =>\n  new ToolError({\n    tool: name,\n    message: `Tool is not configured: ${name}`,\n    cause: 'not_found'\n  })\n\nconst unknownToMessage = (error: unknown) =>\n  error instanceof Error ? error.message : String(error)\n\nconst objectField = (input: unknown, key: string) =>\n  input !== null && typeof input === 'object' ? Object.getOwnPropertyDescriptor(input, key)?.value : undefined\n\nconst isObjectRecord = (input: unknown): input is Readonly<Record<string, unknown>> =>\n  input !== null && typeof input === 'object' && !Array.isArray(input)\n\nconst localDefinitionName = (ref: unknown) => {\n  if (typeof ref !== 'string') {\n    return undefined\n  }\n\n  const prefix = '#/$defs/'\n\n  return ref.startsWith(prefix) ? ref.slice(prefix.length) : undefined\n}\n\nconst hasJsonSchemaType = (input: unknown, type: string) => objectField(input, 'type') === type\n\nconst isEmptyStructJsonSchema = (schema: unknown) => {\n  const anyOf = objectField(schema, 'anyOf')\n\n  return Array.isArray(anyOf) &&\n    anyOf.length === 2 &&\n    anyOf.some(item => hasJsonSchemaType(item, 'object')) &&\n    anyOf.some(item => hasJsonSchemaType(item, 'array'))\n}\n\nconst isEmptyRecordJsonSchema = (schema: unknown) =>\n  hasJsonSchemaType(schema, 'object') &&\n  objectField(schema, 'additionalProperties') === false &&\n  objectField(schema, 'properties') === undefined &&\n  objectField(schema, 'required') === undefined\n\nconst emptyObjectJsonSchema = {\n  type: 'object',\n  properties: {},\n  required: [],\n  additionalProperties: false\n}\n\nconst jsonSchemaFromSchema = (schema: Schema.Top) => {\n  const document = Schema.toJsonSchemaDocument(schema)\n  const definitionName = localDefinitionName(objectField(document.schema, '$ref'))\n  const localDefinition = definitionName === undefined\n    ? undefined\n    : Object.getOwnPropertyDescriptor(document.definitions, definitionName)?.value\n  const rootSchema = isObjectRecord(localDefinition) ? localDefinition : document.schema\n  const remainingDefinitions = definitionName === undefined\n    ? document.definitions\n    : Object.fromEntries(\n        Object.entries(document.definitions).filter(([name]) => name !== definitionName)\n      )\n  const jsonSchema = isEmptyStructJsonSchema(rootSchema) || isEmptyRecordJsonSchema(rootSchema)\n    ? emptyObjectJsonSchema\n    : rootSchema\n\n  return Object.keys(remainingDefinitions).length > 0\n    ? { ...jsonSchema, $defs: remainingDefinitions }\n    : jsonSchema\n}\n\nexport const makeTool = <Context, ParamsSchema extends ToolParamsSchema>(\n  options: MakeToolOptions<Context, ParamsSchema>\n): ToolRegistration<Context> => ({\n  def: ToolDef.make({\n    name: options.name,\n    description: options.description,\n    parameters: jsonSchemaFromSchema(options.parameters),\n    approval: options.approval\n  }),\n  access: options.access,\n  approval: options.approval,\n  isEnabled: options.isEnabled,\n  execute: ({ call, context }) =>\n    Schema.decodeUnknownEffect(options.parameters)(call.params).pipe(\n      Effect.mapError(error =>\n        new ToolError({\n          tool: options.name,\n          message: options.invalidParamsMessage?.(error) ?? `Invalid ${options.name} arguments: ${unknownToMessage(error)}`,\n          cause: 'validation'\n        })\n      ),\n      Effect.flatMap(params => options.execute({ call, context, params }))\n    )\n})\n\nconst findDuplicateToolName = <Context>(resolved: ReadonlyArray<ResolvedRegistration<Context>>) => {\n  const names = Arr.map(resolved, item => item.tool.def.name)\n\n  return Arr.findFirst(names, (name, index) => names.indexOf(name) !== index)\n}\n\nexport const resolveTools = <Context>(\n  modules: ReadonlyArray<ToolModule<Context>>,\n  context: Context\n): Effect.Effect<ResolvedToolSet, ToolRegistryError> =>\n  Effect.gen(function* () {\n    const resolvedByModule = yield* Effect.forEach(modules, toolModule =>\n      resolveModuleTools(toolModule, context)\n    )\n    const resolved = Arr.flatten(resolvedByModule)\n    const duplicateName = findDuplicateToolName(resolved)\n\n    if (Option.isSome(duplicateName)) {\n      return yield* Effect.fail(duplicateToolError(duplicateName.value))\n    }\n\n    const tools = Arr.map(resolved, item => item.tool.def)\n    const metadata = Arr.map(resolved, item => ({\n      moduleId: item.moduleId,\n      name: item.tool.def.name,\n      access: item.tool.access\n    }))\n\n    const execute = (call: ToolCall) =>\n      Option.match(\n        Arr.findFirst(resolved, item => item.tool.def.name === call.name),\n        {\n          onNone: () => Effect.fail(missingToolError(call.name)),\n          onSome: match => match.tool.execute({ call, context })\n        }\n      )\n\n    return { tools, metadata, execute }\n  })\n\nexport const makeToolExecutorLayer = (toolSet: ResolvedToolSet) =>\n  Layer.succeed(ToolExecutor, ToolExecutor.of({ execute: toolSet.execute }))\n"],"mappings":"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"}

package/dist/tools/task.d.mts

@@ -0,0 +1,34 @@
+import { ToolModule, ToolRegistration } from "./registry.mjs";
+import { Effect } from "effect";
+import * as Schema from "effect/Schema";
+import { ToolCall, ToolResult } from "@yolk-sdk/agent/protocol";
+import { ToolError } from "@yolk-sdk/agent/loop";
+
+//#region src/tools/task.d.ts
+declare const taskToolName = "task";
+declare const TaskToolParams: Schema.Struct<{
+  readonly description: Schema.String;
+  readonly prompt: Schema.String;
+  readonly subagent_type: Schema.String;
+}>;
+type TaskToolParams = typeof TaskToolParams.Type;
+type TaskSubagentDefinition = {
+  readonly name: string;
+  readonly description: string;
+};
+type TaskExecutionInput<Context> = {
+  readonly call: ToolCall;
+  readonly context: Context;
+  readonly params: TaskToolParams;
+};
+type TaskToolOptions<Context> = {
+  readonly subagents: ReadonlyArray<TaskSubagentDefinition>;
+  readonly execute: (input: TaskExecutionInput<Context>) => Effect.Effect<ToolResult, ToolError>;
+};
+declare const makeTaskToolRegistration: <Context>(options: TaskToolOptions<Context>) => ToolRegistration<Context>;
+declare const makeTaskToolDef: (subagents: ReadonlyArray<TaskSubagentDefinition>) => import("@yolk-sdk/agent/protocol").ToolDef;
+declare const makeTaskToolModule: <Context>(options: TaskToolOptions<Context>) => ToolModule<Context>;
+declare const formatTaskResult: (output: string) => string;
+//#endregion
+export { TaskExecutionInput, TaskSubagentDefinition, TaskToolOptions, TaskToolParams, formatTaskResult, makeTaskToolDef, makeTaskToolModule, makeTaskToolRegistration, taskToolName };
+//# sourceMappingURL=task.d.mts.map

package/dist/tools/task.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.d.mts","names":[],"sources":["../../src/tools/task.ts"],"mappings":";;;;;;;cAMa,YAAA;AAAA,cAEP,cAAA,EAAc,MAAA,CAAA,MAAA;EAAA;;;;KAYR,cAAA,UAAwB,cAAA,CAAe,IAAI;AAAA,KAE3C,sBAAA;EAAA,SACD,IAAA;EAAA,SACA,WAAW;AAAA;AAAA,KAGV,kBAAA;EAAA,SACD,IAAA,EAAM,QAAA;EAAA,SACN,OAAA,EAAS,OAAA;EAAA,SACT,MAAA,EAAQ,cAAA;AAAA;AAAA,KAGP,eAAA;EAAA,SACD,SAAA,EAAW,aAAA,CAAc,sBAAA;EAAA,SACzB,OAAA,GAAU,KAAA,EAAO,kBAAA,CAAmB,OAAA,MAAa,MAAA,CAAO,MAAA,CAAO,UAAA,EAAY,SAAA;AAAA;AAAA,cAgEzE,wBAAA,YACX,OAAA,EAAS,eAAA,CAAgB,OAAA,MACxB,gBAAA,CAAiB,OAAA;AAAA,cAmBP,eAAA,GAAmB,SAAA,EAAW,aAAa,CAAC,sBAAA,yCAAuB,OAAA;AAAA,cAMnE,kBAAA,YAA+B,OAAA,EAAS,eAAA,CAAgB,OAAA,MAAW,UAAA,CAAW,OAAA;AAAA,cAK9E,gBAAA,GAAoB,MAAc"}

package/dist/tools/task.mjs

@@ -0,0 +1,81 @@
+import { makeTool } from "./registry.mjs";
+import { Effect } from "effect";
+import * as Schema from "effect/Schema";
+import { ToolResult } from "@yolk-sdk/agent/protocol";
+import { ToolError } from "@yolk-sdk/agent/loop";
+//#region src/tools/task.ts
+const taskToolName = "task";
+const TaskToolParams = Schema.Struct({
+	description: Schema.String.pipe(Schema.annotate({ description: "A short 3-5 word description of the task." })),
+	prompt: Schema.String.pipe(Schema.annotate({ description: "The complete task instructions for the subagent, including all context it needs." })),
+	subagent_type: Schema.String.pipe(Schema.annotate({ description: "The specialized subagent type to use for this task." }))
+});
+const taskToolError = (message, cause) => new ToolError({
+	tool: taskToolName,
+	message,
+	cause
+});
+const trimmedTaskParams = (params) => ({
+	description: params.description.trim(),
+	prompt: params.prompt.trim(),
+	subagent_type: params.subagent_type.trim()
+});
+const validateTaskParams = (params) => {
+	const trimmed = trimmedTaskParams(params);
+	if (trimmed.description.length === 0) return Effect.fail(taskToolError("description must not be empty", "validation"));
+	if (trimmed.prompt.length === 0) return Effect.fail(taskToolError("prompt must not be empty", "validation"));
+	if (trimmed.subagent_type.length === 0) return Effect.fail(taskToolError("subagent_type must not be empty", "validation"));
+	return Effect.succeed(trimmed);
+};
+const findSubagent = (subagents, name) => subagents.find((subagent) => subagent.name === name);
+const requireKnownSubagent = (subagents, name) => {
+	const subagent = findSubagent(subagents, name);
+	return subagent === void 0 ? Effect.fail(taskToolError(`Unknown subagent type: ${name}`, "validation")) : Effect.succeed(subagent);
+};
+const subagentDescription = (subagent) => `- ${subagent.name}: ${subagent.description}`;
+const taskToolDescription = (subagents) => [
+	"Launch a new agent to handle complex, multistep tasks autonomously.",
+	"Use this when delegating focused work to a specialized subagent would save context or allow parallel exploration.",
+	"To run subagents in parallel, call this task tool multiple times in the same assistant response.",
+	"Yolk runs same-turn task calls concurrently automatically.",
+	"A fresh subagent only sees the prompt you provide, so include all required context.",
+	"Subagents can use their normal tools but cannot launch further task subagents in v1.",
+	subagents.length === 0 ? "No subagent types are currently available." : `Available subagent types:\n${subagents.map(subagentDescription).join("\n")}`
+].join("\n\n");
+const makeTaskToolRegistration = (options) => makeTool({
+	name: taskToolName,
+	description: taskToolDescription(options.subagents),
+	parameters: TaskToolParams,
+	access: "read",
+	invalidParamsMessage: (error) => `Invalid task arguments: ${error instanceof Error ? error.message : String(error)}`,
+	execute: ({ call, context, params }) => Effect.gen(function* () {
+		if (call.name !== "task") return yield* Effect.fail(taskToolError(`Tool is not configured: ${call.name}`, "not_found"));
+		const normalizedParams = yield* validateTaskParams(params);
+		yield* requireKnownSubagent(options.subagents, normalizedParams.subagent_type);
+		return yield* options.execute({
+			call,
+			context,
+			params: normalizedParams
+		});
+	})
+});
+const makeTaskToolDef = (subagents) => makeTaskToolRegistration({
+	subagents,
+	execute: ({ call }) => Effect.succeed(ToolResult.make({
+		toolCallId: call.id,
+		content: ""
+	}))
+}).def;
+const makeTaskToolModule = (options) => ({
+	id: "task",
+	tools: [makeTaskToolRegistration(options)]
+});
+const formatTaskResult = (output) => [
+	"<task_result>",
+	output,
+	"</task_result>"
+].join("\n");
+//#endregion
+export { formatTaskResult, makeTaskToolDef, makeTaskToolModule, makeTaskToolRegistration, taskToolName };
+
+//# sourceMappingURL=task.mjs.map

package/dist/tools/task.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"task.mjs","names":[],"sources":["../../src/tools/task.ts"],"sourcesContent":["import { Effect } from 'effect'\nimport * as Schema from 'effect/Schema'\nimport { ToolError } from '@yolk-sdk/agent/loop'\nimport { ToolResult, type ToolCall } from '@yolk-sdk/agent/protocol'\nimport { makeTool, type ToolModule, type ToolRegistration } from './registry.ts'\n\nexport const taskToolName = 'task'\n\nconst TaskToolParams = Schema.Struct({\n  description: Schema.String.pipe(Schema.annotate({ description: 'A short 3-5 word description of the task.' })),\n  prompt: Schema.String.pipe(\n    Schema.annotate({\n      description: 'The complete task instructions for the subagent, including all context it needs.'\n    })\n  ),\n  subagent_type: Schema.String.pipe(\n    Schema.annotate({ description: 'The specialized subagent type to use for this task.' })\n  )\n})\n\nexport type TaskToolParams = typeof TaskToolParams.Type\n\nexport type TaskSubagentDefinition = {\n  readonly name: string\n  readonly description: string\n}\n\nexport type TaskExecutionInput<Context> = {\n  readonly call: ToolCall\n  readonly context: Context\n  readonly params: TaskToolParams\n}\n\nexport type TaskToolOptions<Context> = {\n  readonly subagents: ReadonlyArray<TaskSubagentDefinition>\n  readonly execute: (input: TaskExecutionInput<Context>) => Effect.Effect<ToolResult, ToolError>\n}\n\nconst taskToolError = (message: string, cause: ToolError['cause']) =>\n  new ToolError({\n    tool: taskToolName,\n    message,\n    cause\n  })\n\nconst trimmedTaskParams = (params: TaskToolParams) => ({\n  description: params.description.trim(),\n  prompt: params.prompt.trim(),\n  subagent_type: params.subagent_type.trim()\n})\n\nconst validateTaskParams = (params: TaskToolParams) => {\n  const trimmed = trimmedTaskParams(params)\n\n  if (trimmed.description.length === 0) {\n    return Effect.fail(taskToolError('description must not be empty', 'validation'))\n  }\n\n  if (trimmed.prompt.length === 0) {\n    return Effect.fail(taskToolError('prompt must not be empty', 'validation'))\n  }\n\n  if (trimmed.subagent_type.length === 0) {\n    return Effect.fail(taskToolError('subagent_type must not be empty', 'validation'))\n  }\n\n  return Effect.succeed(trimmed)\n}\n\nconst findSubagent = (subagents: ReadonlyArray<TaskSubagentDefinition>, name: string) =>\n  subagents.find(subagent => subagent.name === name)\n\nconst requireKnownSubagent = (\n  subagents: ReadonlyArray<TaskSubagentDefinition>,\n  name: string\n) => {\n  const subagent = findSubagent(subagents, name)\n\n  return subagent === undefined\n    ? Effect.fail(taskToolError(`Unknown subagent type: ${name}`, 'validation'))\n    : Effect.succeed(subagent)\n}\n\nconst subagentDescription = (subagent: TaskSubagentDefinition) =>\n  `- ${subagent.name}: ${subagent.description}`\n\nconst taskToolDescription = (subagents: ReadonlyArray<TaskSubagentDefinition>) =>\n  [\n    'Launch a new agent to handle complex, multistep tasks autonomously.',\n    'Use this when delegating focused work to a specialized subagent would save context or allow parallel exploration.',\n    'To run subagents in parallel, call this task tool multiple times in the same assistant response.',\n    'Yolk runs same-turn task calls concurrently automatically.',\n    'A fresh subagent only sees the prompt you provide, so include all required context.',\n    'Subagents can use their normal tools but cannot launch further task subagents in v1.',\n    subagents.length === 0\n      ? 'No subagent types are currently available.'\n      : `Available subagent types:\\n${subagents.map(subagentDescription).join('\\n')}`\n  ].join('\\n\\n')\n\nexport const makeTaskToolRegistration = <Context>(\n  options: TaskToolOptions<Context>\n): ToolRegistration<Context> => makeTool({\n  name: taskToolName,\n  description: taskToolDescription(options.subagents),\n  parameters: TaskToolParams,\n  access: 'read',\n  invalidParamsMessage: error => `Invalid task arguments: ${error instanceof Error ? error.message : String(error)}`,\n  execute: ({ call, context, params }) =>\n    Effect.gen(function* () {\n      if (call.name !== taskToolName) {\n        return yield* Effect.fail(taskToolError(`Tool is not configured: ${call.name}`, 'not_found'))\n      }\n\n      const normalizedParams = yield* validateTaskParams(params)\n      yield* requireKnownSubagent(options.subagents, normalizedParams.subagent_type)\n\n      return yield* options.execute({ call, context, params: normalizedParams })\n    })\n})\n\nexport const makeTaskToolDef = (subagents: ReadonlyArray<TaskSubagentDefinition>) =>\n  makeTaskToolRegistration({\n    subagents,\n    execute: ({ call }) => Effect.succeed(ToolResult.make({ toolCallId: call.id, content: '' }))\n  }).def\n\nexport const makeTaskToolModule = <Context>(options: TaskToolOptions<Context>): ToolModule<Context> => ({\n  id: 'task',\n  tools: [makeTaskToolRegistration(options)]\n})\n\nexport const formatTaskResult = (output: string) => ['<task_result>', output, '</task_result>'].join('\\n')\n"],"mappings":";;;;;;AAMA,MAAa,eAAe;AAE5B,MAAM,iBAAiB,OAAO,OAAO;CACnC,aAAa,OAAO,OAAO,KAAK,OAAO,SAAS,EAAE,aAAa,4CAA4C,CAAC,CAAC;CAC7G,QAAQ,OAAO,OAAO,KACpB,OAAO,SAAS,EACd,aAAa,mFACf,CAAC,CACH;CACA,eAAe,OAAO,OAAO,KAC3B,OAAO,SAAS,EAAE,aAAa,sDAAsD,CAAC,CACxF;AACF,CAAC;AAoBD,MAAM,iBAAiB,SAAiB,UACtC,IAAI,UAAU;CACZ,MAAM;CACN;CACA;AACF,CAAC;AAEH,MAAM,qBAAqB,YAA4B;CACrD,aAAa,OAAO,YAAY,KAAK;CACrC,QAAQ,OAAO,OAAO,KAAK;CAC3B,eAAe,OAAO,cAAc,KAAK;AAC3C;AAEA,MAAM,sBAAsB,WAA2B;CACrD,MAAM,UAAU,kBAAkB,MAAM;CAExC,IAAI,QAAQ,YAAY,WAAW,GACjC,OAAO,OAAO,KAAK,cAAc,iCAAiC,YAAY,CAAC;CAGjF,IAAI,QAAQ,OAAO,WAAW,GAC5B,OAAO,OAAO,KAAK,cAAc,4BAA4B,YAAY,CAAC;CAG5E,IAAI,QAAQ,cAAc,WAAW,GACnC,OAAO,OAAO,KAAK,cAAc,mCAAmC,YAAY,CAAC;CAGnF,OAAO,OAAO,QAAQ,OAAO;AAC/B;AAEA,MAAM,gBAAgB,WAAkD,SACtE,UAAU,MAAK,aAAY,SAAS,SAAS,IAAI;AAEnD,MAAM,wBACJ,WACA,SACG;CACH,MAAM,WAAW,aAAa,WAAW,IAAI;CAE7C,OAAO,aAAa,KAAA,IAChB,OAAO,KAAK,cAAc,0BAA0B,QAAQ,YAAY,CAAC,IACzE,OAAO,QAAQ,QAAQ;AAC7B;AAEA,MAAM,uBAAuB,aAC3B,KAAK,SAAS,KAAK,IAAI,SAAS;AAElC,MAAM,uBAAuB,cAC3B;CACE;CACA;CACA;CACA;CACA;CACA;CACA,UAAU,WAAW,IACjB,+CACA,8BAA8B,UAAU,IAAI,mBAAmB,EAAE,KAAK,IAAI;AAChF,EAAE,KAAK,MAAM;AAEf,MAAa,4BACX,YAC8B,SAAS;CACvC,MAAM;CACN,aAAa,oBAAoB,QAAQ,SAAS;CAClD,YAAY;CACZ,QAAQ;CACR,uBAAsB,UAAS,2BAA2B,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;CAC/G,UAAU,EAAE,MAAM,SAAS,aACzB,OAAO,IAAI,aAAa;EACtB,IAAI,KAAK,SAAA,QACP,OAAO,OAAO,OAAO,KAAK,cAAc,2BAA2B,KAAK,QAAQ,WAAW,CAAC;EAG9F,MAAM,mBAAmB,OAAO,mBAAmB,MAAM;EACzD,OAAO,qBAAqB,QAAQ,WAAW,iBAAiB,aAAa;EAE7E,OAAO,OAAO,QAAQ,QAAQ;GAAE;GAAM;GAAS,QAAQ;EAAiB,CAAC;CAC3E,CAAC;AACL,CAAC;AAED,MAAa,mBAAmB,cAC9B,yBAAyB;CACvB;CACA,UAAU,EAAE,WAAW,OAAO,QAAQ,WAAW,KAAK;EAAE,YAAY,KAAK;EAAI,SAAS;CAAG,CAAC,CAAC;AAC7F,CAAC,EAAE;AAEL,MAAa,sBAA+B,aAA4D;CACtG,IAAI;CACJ,OAAO,CAAC,yBAAyB,OAAO,CAAC;AAC3C;AAEA,MAAa,oBAAoB,WAAmB;CAAC;CAAiB;CAAQ;AAAgB,EAAE,KAAK,IAAI"}

package/package.json

@@ -0,0 +1,86 @@
+{
+  "name": "@yolk-sdk/agent",
+  "version": "0.0.1-canary.0",
+  "description": "Protocol, loop, runtime, client, and tool primitives for building Yolk agents.",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/magoz/yolk-sdk.git",
+    "directory": "packages/agent"
+  },
+  "bugs": {
+    "url": "https://github.com/magoz/yolk-sdk/issues"
+  },
+  "homepage": "https://github.com/magoz/yolk-sdk#readme",
+  "keywords": [
+    "agent",
+    "agents",
+    "llm",
+    "tools",
+    "runtime",
+    "effect"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    },
+    "./client": {
+      "types": "./dist/client/index.d.mts",
+      "import": "./dist/client/index.mjs",
+      "default": "./dist/client/index.mjs"
+    },
+    "./loop": {
+      "types": "./dist/loop/index.d.mts",
+      "import": "./dist/loop/index.mjs",
+      "default": "./dist/loop/index.mjs"
+    },
+    "./loop/testing": {
+      "types": "./dist/loop/testing/index.d.mts",
+      "import": "./dist/loop/testing/index.mjs",
+      "default": "./dist/loop/testing/index.mjs"
+    },
+    "./protocol": {
+      "types": "./dist/protocol/index.d.mts",
+      "import": "./dist/protocol/index.mjs",
+      "default": "./dist/protocol/index.mjs"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/index.d.mts",
+      "import": "./dist/runtime/index.mjs",
+      "default": "./dist/runtime/index.mjs"
+    },
+    "./tools": {
+      "types": "./dist/tools/index.d.mts",
+      "import": "./dist/tools/index.mjs",
+      "default": "./dist/tools/index.mjs"
+    }
+  },
+  "files": [
+    "src/**/*.ts",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "dist/**/*",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "effect": "4.0.0-beta.65"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc -p tsconfig.json --noEmit",
+    "test": "vitest run --passWithNoTests",
+    "test:run": "vitest run --passWithNoTests"
+  }
+}

package/src/client/README.md

@@ -0,0 +1,23 @@
+# @yolk-sdk/agent/client
+
+Framework-agnostic client transport and state helpers for Yolk agents.
+
+## What it provides
+
+- Effect stream and async generator helpers for streamed `AgentEvent`s.
+- Generic client state reducer helpers.
+- Non-empty `AgentTranscript` type.
+- Tool run lifecycle state.
+- HITL response submission helpers for approvals and questions.
+- Typed transport errors.
+
+## Use it when
+
+- A browser, CLI, or other client needs to consume agent events from an app endpoint.
+- You need protocol state without React hooks or UI components.
+
+## Boundaries
+
+- No React.
+- No UI components.
+- No auth chrome, provider defaults, or app routes.

package/src/client/index.ts

@@ -0,0 +1,43 @@
+export {
+  appendAgentMessage,
+  applyAgentEvent,
+  completedToolRuns,
+  initialAgentClientState,
+  isActiveToolRun,
+  markAgentAborted,
+  markAgentError,
+  reduceAgentEvents,
+  submitAgentUserMessage
+} from './state.ts'
+export type {
+  AgentClientState,
+  AgentRunStatus,
+  AgentToolRun,
+  AgentTranscript,
+  ApplyAgentEventOptions
+} from './state.ts'
+export {
+  AgentTransportError,
+  cancelAgentRun,
+  collectAgentEvents,
+  collectAgentEventsEffect,
+  streamQuestionResponseEventStream,
+  streamCloudflareAgentEventStream,
+  streamCloudflareAgentEvents,
+  streamAgentEvents,
+  streamAgentEventStream,
+  streamAgentRunEvents,
+  streamAgentRunEventStream,
+  streamToolApprovalResponseEventStream,
+  submitQuestionResponse,
+  submitToolApprovalResponse
+} from './transport.ts'
+export type {
+  AgentHttpResponseInfo,
+  CancelAgentRunRequest,
+  SubmitQuestionResponseRequest,
+  SubmitToolApprovalResponseRequest,
+  StreamAgentEventsRequest,
+  StreamAgentRunEventsRequest,
+  StreamCloudflareAgentEventsRequest
+} from './transport.ts'