@yolk-sdk/agent 0.0.1-canary.0

package/src/loop/error.ts

@@ -0,0 +1,105 @@
+import * as Schema from 'effect/Schema'
+import { AgentError, type AgentErrorCode } from '@yolk-sdk/agent/protocol'
+
+export class LLMError extends Schema.TaggedErrorClass<LLMError>()('LLMError', {
+  cause: Schema.Literals([
+    'validation_error',
+    'provider_error',
+    'rate_limit',
+    'context_overflow',
+    'invalid_response'
+  ]),
+  message: Schema.String,
+  retryable: Schema.Boolean
+}) {}
+
+export class FauxExhaustedError extends Schema.TaggedErrorClass<FauxExhaustedError>()(
+  'FauxExhaustedError',
+  {
+    message: Schema.String
+  }
+) {}
+
+export class ToolError extends Schema.TaggedErrorClass<ToolError>()('ToolError', {
+  tool: Schema.String,
+  message: Schema.String,
+  cause: Schema.Literals([
+    'validation',
+    'invalid_input',
+    'execution',
+    'timeout',
+    'permission',
+    'denied',
+    'not_found',
+    'unavailable'
+  ])
+}) {}
+
+export class ContextTransformError extends Schema.TaggedErrorClass<ContextTransformError>()(
+  'ContextTransformError',
+  {
+    cause: Schema.Literals(['context_overflow', 'invalid_response']),
+    message: Schema.String,
+    retryable: Schema.Boolean
+  }
+) {}
+
+export class AbortError extends Schema.TaggedErrorClass<AbortError>()('AbortError', {
+  reason: Schema.Literals(['user', 'system', 'max_turns'])
+}) {}
+
+export type LLMProviderError = LLMError | FauxExhaustedError | AbortError
+
+export type AgentLoopError = LLMProviderError | ToolError | ContextTransformError
+
+const toolErrorCode = (error: ToolError): AgentErrorCode => {
+  switch (error.cause) {
+    case 'validation':
+    case 'invalid_input':
+      return 'validation_error'
+    case 'timeout':
+      return 'tool_timeout'
+    case 'permission':
+    case 'denied':
+      return 'tool_denied'
+    case 'execution':
+    case 'not_found':
+    case 'unavailable':
+      return 'tool_error'
+  }
+}
+
+export const agentLoopErrorToAgentError = (error: AgentLoopError): AgentError => {
+  switch (error._tag) {
+    case 'LLMError':
+      return AgentError.make({
+        code: error.cause,
+        message: error.message,
+        retryable: error.retryable
+      })
+    case 'ToolError':
+      return AgentError.make({
+        code: toolErrorCode(error),
+        message: error.message,
+        retryable: error.cause === 'timeout'
+      })
+    case 'ContextTransformError':
+      return AgentError.make({
+        code: error.cause,
+        message: error.message,
+        retryable: error.retryable
+      })
+    case 'AbortError':
+      return AgentError.make({
+        code: 'aborted',
+        message: `Agent run aborted: ${error.reason}`,
+        retryable: error.reason === 'system'
+      })
+    case 'FauxExhaustedError':
+      return AgentError.make({
+        code: 'provider_error',
+        message: error.message,
+        retryable: false
+      })
+  }
+}

package/src/loop/index.ts

@@ -0,0 +1,35 @@
+export {
+  accumulateAssistantMessage,
+  collectReasoning,
+  collectText,
+  collectToolCalls
+} from './accumulator.ts'
+export {
+  AbortError,
+  agentLoopErrorToAgentError,
+  ContextTransformError,
+  FauxExhaustedError,
+  LLMError,
+  ToolError
+} from './error.ts'
+export type { AgentLoopError, LLMProviderError } from './error.ts'
+export {
+  LLMDone,
+  LLMEvent,
+  LLMProviderToolResult,
+  LLMReasoningDelta,
+  LLMTextDelta,
+  LLMToolCall,
+  LLMToolInputDelta,
+  LLMToolInputStart,
+  LLMUsage
+} from './llm-event.ts'
+export { run, runModelTurn, runToolBatch } from './run.ts'
+export type { AgentLoopRunId, ModelTurnConfig, RunConfig, ToolBatchConfig } from './run.ts'
+export { ContextTransformer } from './services/context-transformer.ts'
+export type { ContextTransformResult } from './services/context-transformer.ts'
+export { LLMProvider } from './services/llm-provider.ts'
+export type { LLMRequest } from './services/llm-provider.ts'
+export { LoopConfig } from './services/loop-config.ts'
+export type { LoopConfigShape } from './services/loop-config.ts'
+export { ToolExecutor } from './services/tool-executor.ts'

package/src/loop/llm-event.ts

@@ -0,0 +1,52 @@
+import * as Schema from 'effect/Schema'
+import { AgentUsage, ToolCall, ToolResult } from '@yolk-sdk/agent/protocol'
+
+export class LLMTextDelta extends Schema.TaggedClass<LLMTextDelta>()('TextDelta', {
+  text: Schema.String
+}) {}
+
+export class LLMReasoningDelta extends Schema.TaggedClass<LLMReasoningDelta>()('ReasoningDelta', {
+  text: Schema.String
+}) {}
+
+export class LLMDone extends Schema.TaggedClass<LLMDone>()('Done', {
+  stopReason: Schema.Literals(['stop', 'tool_use'])
+}) {}
+
+export class LLMToolCall extends Schema.TaggedClass<LLMToolCall>()('ToolCall', {
+  call: ToolCall
+}) {}
+
+export class LLMToolInputStart extends Schema.TaggedClass<LLMToolInputStart>()('ToolInputStart', {
+  id: Schema.String,
+  name: Schema.optional(Schema.String)
+}) {}
+
+export class LLMToolInputDelta extends Schema.TaggedClass<LLMToolInputDelta>()('ToolInputDelta', {
+  id: Schema.String,
+  delta: Schema.String
+}) {}
+
+export class LLMProviderToolResult extends Schema.TaggedClass<LLMProviderToolResult>()(
+  'ProviderToolResult',
+  {
+    call: ToolCall,
+    result: ToolResult
+  }
+) {}
+
+export class LLMUsage extends Schema.TaggedClass<LLMUsage>()('Usage', {
+  usage: AgentUsage
+}) {}
+
+export const LLMEvent = Schema.Union([
+  LLMTextDelta,
+  LLMReasoningDelta,
+  LLMDone,
+  LLMToolCall,
+  LLMToolInputStart,
+  LLMToolInputDelta,
+  LLMProviderToolResult,
+  LLMUsage
+])
+export type LLMEvent = typeof LLMEvent.Type