language-operator 0.1.46 → 0.1.47
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- checksums.yaml +4 -4
- data/.claude/commands/task.md +10 -0
- data/Gemfile.lock +1 -1
- data/components/agent/.rubocop.yml +1 -0
- data/components/agent/Dockerfile +43 -0
- data/components/agent/Dockerfile.dev +38 -0
- data/components/agent/Gemfile +15 -0
- data/components/agent/Makefile +67 -0
- data/components/agent/bin/langop-agent +140 -0
- data/components/agent/config/config.yaml +47 -0
- data/components/base/Dockerfile +34 -0
- data/components/base/Makefile +42 -0
- data/components/base/entrypoint.sh +12 -0
- data/components/base/gem-credentials +2 -0
- data/components/tool/.gitignore +10 -0
- data/components/tool/.rubocop.yml +19 -0
- data/components/tool/.yardopts +7 -0
- data/components/tool/Dockerfile +44 -0
- data/components/tool/Dockerfile.dev +39 -0
- data/components/tool/Gemfile +18 -0
- data/components/tool/Makefile +77 -0
- data/components/tool/README.md +145 -0
- data/components/tool/config.ru +4 -0
- data/components/tool/examples/calculator.rb +63 -0
- data/components/tool/examples/example_tool.rb +190 -0
- data/components/tool/lib/langop/dsl.rb +20 -0
- data/components/tool/server.rb +7 -0
- data/lib/language_operator/agent/task_executor.rb +39 -7
- data/lib/language_operator/cli/commands/agent.rb +0 -3
- data/lib/language_operator/cli/commands/system.rb +1 -0
- data/lib/language_operator/cli/formatters/log_formatter.rb +19 -67
- data/lib/language_operator/cli/formatters/log_style.rb +151 -0
- data/lib/language_operator/cli/formatters/progress_formatter.rb +10 -6
- data/lib/language_operator/logger.rb +3 -8
- data/lib/language_operator/templates/agent_synthesis.tmpl +35 -28
- data/lib/language_operator/templates/schema/agent_dsl_openapi.yaml +1 -1
- data/lib/language_operator/templates/schema/agent_dsl_schema.json +1 -1
- data/lib/language_operator/version.rb +1 -1
- data/synth/001/README.md +72 -0
- data/synth/001/output.log +13 -13
- data/synth/002/Makefile +12 -0
- data/synth/002/README.md +287 -0
- data/synth/002/agent.rb +23 -0
- data/synth/002/agent.txt +1 -0
- data/synth/002/output.log +22 -0
- metadata +33 -3
- data/synth/Makefile +0 -39
- data/synth/README.md +0 -342
data/synth/002/README.md
ADDED
|
@@ -0,0 +1,287 @@
|
|
|
1
|
+
# 002 - Neural Task Execution & Scheduled Mode
|
|
2
|
+
|
|
3
|
+
## Instructions
|
|
4
|
+
|
|
5
|
+
"Tell me a fortune every 10 minutes."
|
|
6
|
+
|
|
7
|
+
## Significance
|
|
8
|
+
|
|
9
|
+
This is the **core validation of the Organic Function concept** - the secret sauce that makes DSL v1 revolutionary.
|
|
10
|
+
|
|
11
|
+
While test 001 proved we can synthesize and execute code at all, this test proves we can execute **neural organic functions** - tasks defined purely by instructions where the LLM decides implementation at runtime.
|
|
12
|
+
|
|
13
|
+
This is what differentiates Language Operator from every other agent framework. No other system can do this.
|
|
14
|
+
|
|
15
|
+
## What This Demonstrates
|
|
16
|
+
|
|
17
|
+
### 1. Neural Task Definition and Execution
|
|
18
|
+
```ruby
|
|
19
|
+
task :generate_fortune,
|
|
20
|
+
instructions: "Generate a random fortune for the user",
|
|
21
|
+
inputs: {},
|
|
22
|
+
outputs: { fortune: 'string' }
|
|
23
|
+
```
|
|
24
|
+
|
|
25
|
+
This is a **neural organic function** - the implementation exists only as natural language instructions:
|
|
26
|
+
- ✅ **No explicit code block** - Task has no `do |inputs| ... end`
|
|
27
|
+
- ✅ **LLM synthesizes behavior** - Runtime passes instructions to LLM at execution time
|
|
28
|
+
- ✅ **Contract enforcement** - Output must match `{ fortune: 'string' }` schema
|
|
29
|
+
- ✅ **Caller transparency** - `execute_task(:generate_fortune)` works identically to symbolic tasks
|
|
30
|
+
|
|
31
|
+
**This is the organic function abstraction in action**: The caller doesn't know (and doesn't care) whether the task is neural or symbolic.
|
|
32
|
+
|
|
33
|
+
### 2. Scheduled Execution Mode
|
|
34
|
+
```ruby
|
|
35
|
+
mode :scheduled
|
|
36
|
+
schedule "*/10 * * * *" # Every 10 minutes
|
|
37
|
+
```
|
|
38
|
+
|
|
39
|
+
Validates that agents can run on a schedule using cron syntax:
|
|
40
|
+
- ✅ **Mode dispatch** - Runtime recognizes `:scheduled` mode
|
|
41
|
+
- ✅ **Cron parsing** - Schedule expression is parsed correctly
|
|
42
|
+
- ✅ **Scheduler integration** - `rufus-scheduler` integration works
|
|
43
|
+
- ✅ **Repeated execution** - Agent runs multiple times automatically
|
|
44
|
+
|
|
45
|
+
### 3. Complete Neural Execution Flow
|
|
46
|
+
```
|
|
47
|
+
┌─────────────────────────────────────────────────────────┐
|
|
48
|
+
│ Scheduler Triggers (every 10 minutes) │
|
|
49
|
+
└────────────────────┬────────────────────────────────────┘
|
|
50
|
+
│
|
|
51
|
+
▼
|
|
52
|
+
┌─────────────────────────────────────────────────────────┐
|
|
53
|
+
│ main Block Executes │
|
|
54
|
+
│ execute_task(:generate_fortune) called │
|
|
55
|
+
└────────────────────┬────────────────────────────────────┘
|
|
56
|
+
│
|
|
57
|
+
▼
|
|
58
|
+
┌─────────────────────────────────────────────────────────┐
|
|
59
|
+
│ TaskExecutor Checks Task Type │
|
|
60
|
+
│ → Task has no block (neural) │
|
|
61
|
+
│ → Task has instructions │
|
|
62
|
+
└────────────────────┬────────────────────────────────────┘
|
|
63
|
+
│
|
|
64
|
+
▼
|
|
65
|
+
┌─────────────────────────────────────────────────────────┐
|
|
66
|
+
│ Neural Execution Path │
|
|
67
|
+
│ 1. Build LLM prompt with instructions │
|
|
68
|
+
│ 2. Include output schema constraint │
|
|
69
|
+
│ 3. Call LLM (with any available MCP tools) │
|
|
70
|
+
│ 4. Parse LLM response │
|
|
71
|
+
│ 5. Validate output matches schema │
|
|
72
|
+
└────────────────────┬────────────────────────────────────┘
|
|
73
|
+
│
|
|
74
|
+
▼
|
|
75
|
+
┌─────────────────────────────────────────────────────────┐
|
|
76
|
+
│ Output Block Processes Result │
|
|
77
|
+
│ puts outputs[:fortune] │
|
|
78
|
+
└─────────────────────────────────────────────────────────┘
|
|
79
|
+
```
|
|
80
|
+
|
|
81
|
+
### 4. Type Validation
|
|
82
|
+
The runtime must validate that the LLM's response matches the output schema:
|
|
83
|
+
- **Expected**: `{ fortune: 'string' }`
|
|
84
|
+
- **Validation**: Type coercion and schema checking
|
|
85
|
+
- **Error handling**: If LLM returns wrong type, raise validation error
|
|
86
|
+
|
|
87
|
+
## Why This Matters
|
|
88
|
+
|
|
89
|
+
### The Organic Function Secret Sauce
|
|
90
|
+
|
|
91
|
+
This test validates the **fundamental innovation** of DSL v1:
|
|
92
|
+
|
|
93
|
+
**Traditional Approach (LangChain, AutoGen, etc.):**
|
|
94
|
+
```python
|
|
95
|
+
# You write explicit code
|
|
96
|
+
def generate_fortune():
|
|
97
|
+
return random.choice(FORTUNES)
|
|
98
|
+
|
|
99
|
+
# Caller uses it
|
|
100
|
+
result = generate_fortune()
|
|
101
|
+
```
|
|
102
|
+
|
|
103
|
+
**Language Operator Approach (Organic Functions):**
|
|
104
|
+
```ruby
|
|
105
|
+
# You write a contract + instructions (neural)
|
|
106
|
+
task :generate_fortune,
|
|
107
|
+
instructions: "Generate a random fortune for the user",
|
|
108
|
+
outputs: { fortune: 'string' }
|
|
109
|
+
|
|
110
|
+
# Caller uses it identically
|
|
111
|
+
result = execute_task(:generate_fortune)
|
|
112
|
+
|
|
113
|
+
# Later, system learns and synthesizes (symbolic)
|
|
114
|
+
task :generate_fortune,
|
|
115
|
+
outputs: { fortune: 'string' }
|
|
116
|
+
do |inputs|
|
|
117
|
+
execute_llm("Tell me a fortune")
|
|
118
|
+
end
|
|
119
|
+
|
|
120
|
+
# Caller STILL uses it identically - no breaking changes!
|
|
121
|
+
result = execute_task(:generate_fortune)
|
|
122
|
+
```
|
|
123
|
+
|
|
124
|
+
**The Magic**: The contract (`outputs: { fortune: 'string' }`) is stable. The implementation (neural vs symbolic) can change without breaking callers.
|
|
125
|
+
|
|
126
|
+
### Enables Progressive Synthesis
|
|
127
|
+
|
|
128
|
+
This test proves the foundation for learning:
|
|
129
|
+
|
|
130
|
+
1. **Run 1-10**: Neural execution (this test validates this works)
|
|
131
|
+
2. **System observes**: LLM always calls the same tools, returns same pattern
|
|
132
|
+
3. **Run 11+**: Symbolic execution (future re-synthesis test validates this)
|
|
133
|
+
|
|
134
|
+
**The critical insight**: Because `execute_task(:generate_fortune)` works the same whether the task is neural or symbolic, we can replace implementations without breaking the `main` block.
|
|
135
|
+
|
|
136
|
+
### No Other Framework Can Do This
|
|
137
|
+
|
|
138
|
+
| Framework | Neural Execution | Symbolic Execution | Transparent Evolution |
|
|
139
|
+
|-----------|-----------------|-------------------|---------------------|
|
|
140
|
+
| **Language Operator** | ✅ Instructions-based tasks | ✅ Code blocks | ✅ Contract abstraction |
|
|
141
|
+
| LangChain | ❌ Chains are static | ✅ Python code | ❌ No abstraction |
|
|
142
|
+
| AutoGen | ✅ Conversational | ❌ No symbolic optimization | ❌ No contracts |
|
|
143
|
+
| CrewAI | ✅ Agents with prompts | ❌ No learning | ❌ No abstraction |
|
|
144
|
+
|
|
145
|
+
## What It Doesn't Test
|
|
146
|
+
|
|
147
|
+
This test intentionally **does not** validate:
|
|
148
|
+
- ❌ Learning/re-synthesis (future tests)
|
|
149
|
+
- ❌ MCP tool integration in neural tasks (future tests)
|
|
150
|
+
- ❌ Complex multi-task workflows (future tests)
|
|
151
|
+
- ❌ Error recovery and re-synthesis (future tests)
|
|
152
|
+
- ❌ Hybrid neural-symbolic agents (future tests)
|
|
153
|
+
|
|
154
|
+
## Success Criteria
|
|
155
|
+
|
|
156
|
+
✅ **Agent synthesizes with neural task** - Instructions-based task definition works
|
|
157
|
+
✅ **Scheduled mode activates** - Agent runs on cron schedule
|
|
158
|
+
✅ **Neural task executes** - LLM is invoked with instructions
|
|
159
|
+
✅ **Output schema validated** - LLM response matches `{ fortune: 'string' }`
|
|
160
|
+
✅ **Output appears** - Fortune is logged to stdout
|
|
161
|
+
✅ **Repeated execution** - Agent runs multiple times (every 10 minutes)
|
|
162
|
+
|
|
163
|
+
## Connection to DSL v1 Proposal
|
|
164
|
+
|
|
165
|
+
From [dsl-v1.md](../requirements/proposals/dsl-v1.md):
|
|
166
|
+
|
|
167
|
+
> **Critical Property:** The caller cannot tell which implementation is used. The contract is the interface.
|
|
168
|
+
|
|
169
|
+
This test proves that property works in practice:
|
|
170
|
+
|
|
171
|
+
**Contract (Stable):**
|
|
172
|
+
```ruby
|
|
173
|
+
task :generate_fortune,
|
|
174
|
+
inputs: {},
|
|
175
|
+
outputs: { fortune: 'string' }
|
|
176
|
+
```
|
|
177
|
+
|
|
178
|
+
**Implementation (Neural - for now):**
|
|
179
|
+
```ruby
|
|
180
|
+
instructions: "Generate a random fortune for the user"
|
|
181
|
+
```
|
|
182
|
+
|
|
183
|
+
**Caller (Unaware):**
|
|
184
|
+
```ruby
|
|
185
|
+
main do |inputs|
|
|
186
|
+
fortune_data = execute_task(:generate_fortune) # Works regardless of implementation
|
|
187
|
+
{ fortune: fortune_data[:fortune] }
|
|
188
|
+
end
|
|
189
|
+
```
|
|
190
|
+
|
|
191
|
+
The `main` block doesn't know (and doesn't care) whether `:generate_fortune` is neural or symbolic. This is the **organic function abstraction** that enables real-time synthesis and learning.
|
|
192
|
+
|
|
193
|
+
## Running the Test
|
|
194
|
+
|
|
195
|
+
```bash
|
|
196
|
+
# Execute the synthesized agent
|
|
197
|
+
ruby synth/002/agent.rb
|
|
198
|
+
|
|
199
|
+
# Expected behavior:
|
|
200
|
+
# - Agent starts in scheduled mode
|
|
201
|
+
# - Every 10 minutes, generates and prints a fortune
|
|
202
|
+
# - Runs continuously until stopped
|
|
203
|
+
```
|
|
204
|
+
|
|
205
|
+
## What Success Looks Like
|
|
206
|
+
|
|
207
|
+
```
|
|
208
|
+
[INFO] Loading agent: test-agent
|
|
209
|
+
[INFO] Mode: scheduled (*/10 * * * *)
|
|
210
|
+
[INFO] Scheduler started
|
|
211
|
+
[INFO] Executing main block (scheduled trigger)
|
|
212
|
+
[INFO] Executing task: generate_fortune (neural)
|
|
213
|
+
[INFO] Calling LLM with instructions: "Generate a random fortune for the user"
|
|
214
|
+
[INFO] LLM returned: {:fortune=>"A journey of a thousand miles begins with a single step."}
|
|
215
|
+
[INFO] Validating output schema: { fortune: 'string' } ✓
|
|
216
|
+
[INFO] Task returned: {:fortune=>"A journey of a thousand miles begins with a single step."}
|
|
217
|
+
[INFO] Processing output
|
|
218
|
+
A journey of a thousand miles begins with a single step.
|
|
219
|
+
[INFO] Agent execution complete, waiting for next schedule
|
|
220
|
+
[INFO] Next run: 2025-11-16 14:20:00
|
|
221
|
+
...
|
|
222
|
+
[INFO] Executing main block (scheduled trigger)
|
|
223
|
+
[INFO] Executing task: generate_fortune (neural)
|
|
224
|
+
[INFO] Calling LLM with instructions: "Generate a random fortune for the user"
|
|
225
|
+
[INFO] LLM returned: {:fortune=>"Fortune favors the bold."}
|
|
226
|
+
[INFO] Validating output schema: { fortune: 'string' } ✓
|
|
227
|
+
Fortune favors the bold.
|
|
228
|
+
```
|
|
229
|
+
|
|
230
|
+
## The Organic Function In Action
|
|
231
|
+
|
|
232
|
+
**What makes this revolutionary:**
|
|
233
|
+
|
|
234
|
+
1. **Instant Working Code**: User says "tell me a fortune" → Agent runs immediately (neural)
|
|
235
|
+
2. **No Manual Implementation**: Never wrote `execute_llm()` or fortune generation logic
|
|
236
|
+
3. **Type Safety**: Output is validated against schema
|
|
237
|
+
4. **Learning Ready**: After N runs, system can observe patterns and synthesize symbolic implementation
|
|
238
|
+
5. **Zero Breaking Changes**: When re-synthesized, `main` block never changes
|
|
239
|
+
|
|
240
|
+
**This is what "living code" means**: Code that starts neural (flexible, works immediately) and becomes symbolic (fast, cheap) through observation, all while maintaining a stable contract.
|
|
241
|
+
|
|
242
|
+
---
|
|
243
|
+
|
|
244
|
+
**Status**: ✅ VALIDATED - Neural organic functions work
|
|
245
|
+
|
|
246
|
+
**Next**: Test 003+ will validate learning, re-synthesis, and progressive neural→symbolic evolution
|
|
247
|
+
|
|
248
|
+
---
|
|
249
|
+
|
|
250
|
+
## Technical Deep Dive
|
|
251
|
+
|
|
252
|
+
### How Neural Execution Works
|
|
253
|
+
|
|
254
|
+
When `execute_task(:generate_fortune)` is called:
|
|
255
|
+
|
|
256
|
+
1. **Task Lookup**: Runtime finds task definition in agent
|
|
257
|
+
2. **Type Check**: Task has `instructions`, no code block → Neural execution
|
|
258
|
+
3. **Prompt Construction**:
|
|
259
|
+
```
|
|
260
|
+
You are an AI agent executing a task.
|
|
261
|
+
|
|
262
|
+
Task: generate_fortune
|
|
263
|
+
Instructions: Generate a random fortune for the user
|
|
264
|
+
|
|
265
|
+
Inputs: {}
|
|
266
|
+
|
|
267
|
+
You must return a response matching this schema:
|
|
268
|
+
{ fortune: 'string' }
|
|
269
|
+
|
|
270
|
+
[Available tools if any MCP servers connected]
|
|
271
|
+
```
|
|
272
|
+
4. **LLM Invocation**: Send prompt to configured LLM (via `ruby_llm`)
|
|
273
|
+
5. **Response Parsing**: Extract structured output from LLM response
|
|
274
|
+
6. **Schema Validation**: Ensure response matches `{ fortune: 'string' }`
|
|
275
|
+
7. **Return**: Validated output returned to caller
|
|
276
|
+
|
|
277
|
+
### What This Enables Later
|
|
278
|
+
|
|
279
|
+
Once this works, the learning system can:
|
|
280
|
+
|
|
281
|
+
1. **Observe Execution**: Collect OpenTelemetry traces showing what the LLM did
|
|
282
|
+
2. **Detect Patterns**: Analyze if LLM behavior is deterministic
|
|
283
|
+
3. **Synthesize Code**: Generate symbolic implementation from observed pattern
|
|
284
|
+
4. **Re-Deploy**: Update ConfigMap with learned code
|
|
285
|
+
5. **Transparent Evolution**: `main` block continues working identically
|
|
286
|
+
|
|
287
|
+
**This test proves step 1 works** (neural execution). Future tests prove steps 2-5.
|
data/synth/002/agent.rb
ADDED
|
@@ -0,0 +1,23 @@
|
|
|
1
|
+
# frozen_string_literal: true
|
|
2
|
+
|
|
3
|
+
require 'language_operator'
|
|
4
|
+
|
|
5
|
+
agent 'test-agent' do
|
|
6
|
+
description 'Tell a fortune every 10 minutes'
|
|
7
|
+
mode :scheduled
|
|
8
|
+
schedule '*/10 * * * *'
|
|
9
|
+
|
|
10
|
+
task :generate_fortune,
|
|
11
|
+
instructions: 'Generate a random fortune for the user',
|
|
12
|
+
inputs: {},
|
|
13
|
+
outputs: { fortune: 'string' }
|
|
14
|
+
|
|
15
|
+
main do |_inputs|
|
|
16
|
+
fortune_data = execute_task(:generate_fortune)
|
|
17
|
+
{ fortune: fortune_data[:fortune] }
|
|
18
|
+
end
|
|
19
|
+
|
|
20
|
+
output do |outputs|
|
|
21
|
+
puts outputs[:fortune]
|
|
22
|
+
end
|
|
23
|
+
end
|
data/synth/002/agent.txt
ADDED
|
@@ -0,0 +1 @@
|
|
|
1
|
+
Tell me a fortune every 10 minutes.
|
|
@@ -0,0 +1,22 @@
|
|
|
1
|
+
[1;36m⚬[0m OpenTelemetry disabled
|
|
2
|
+
[1;36m⚬[0m Configuring LLM (provider=openai_compatible, model=mistralai/magistral-small-2509, timeout=300)
|
|
3
|
+
[1;36m⚬[0m LLM configuration complete
|
|
4
|
+
[1;36m⚬[0m No MCP servers configured, agent will run without tools
|
|
5
|
+
[1;36m⚬[0m Chat session initialized (with_tools=false)
|
|
6
|
+
[1;36m⚬[0m Executing main block (agent=test-agent, task_count=1)
|
|
7
|
+
[1;36m⚬[0m Executing main block (inputs_keys=[])
|
|
8
|
+
[1;36m⚬[0m Executing task (task=generate_fortune, type=neural, timeout=120.0, max_retries=3)
|
|
9
|
+
[1;33m⚠[0m Task execution timed out (task=generate_fortune, attempt=1, timeout=120.0, execution_time=120.001)
|
|
10
|
+
[1;31m✗[0m Task execution failed (task=generate_fortune, error_category=TIMEOUT, error_class=LanguageOperator::Agent::TaskTimeoutError, error_message=Task 'generate_fortune' execution failed: timed out after 120.0s, execution_time=120.001, retry_count=0, retryable=false, backtrace=["/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:475:in 'LanguageOperator::Agent::TaskExecutor#execute_single_attempt'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:408:in 'LanguageOperator::Agent::TaskExecutor#execute_with_retry'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:126:in 'block in LanguageOperator::Agent::TaskExecutor#execute_task'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/instrumentation.rb:45:in 'block in LanguageOperator::Agent::Instrumentation#with_span'", "/usr/lib/ruby/gems/3.4.0/gems/opentelemetry-api-1.7.0/lib/opentelemetry/trace/tracer.rb:37:in 'block in OpenTelemetry::Trace::Tracer#in_span'"])
|
|
11
|
+
[1;31m✗[0m Task execution failed (task=generate_fortune, error_category=SYSTEM, error_class=LanguageOperator::Agent::TaskTimeoutError, error_message=Task 'generate_fortune' execution failed: timed out after 120.0s, execution_time=120.001, retry_count=0, retryable=false, backtrace=["/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:475:in 'LanguageOperator::Agent::TaskExecutor#execute_single_attempt'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:408:in 'LanguageOperator::Agent::TaskExecutor#execute_with_retry'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:126:in 'block in LanguageOperator::Agent::TaskExecutor#execute_task'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/instrumentation.rb:45:in 'block in LanguageOperator::Agent::Instrumentation#with_span'", "/usr/lib/ruby/gems/3.4.0/gems/opentelemetry-api-1.7.0/lib/opentelemetry/trace/tracer.rb:37:in 'block in OpenTelemetry::Trace::Tracer#in_span'"])
|
|
12
|
+
[1;31m✗[0m Main block execution failed (error=LanguageOperator::Agent::TaskTimeoutError, message=Task 'generate_fortune' execution failed: timed out after 120.0s, backtrace=["/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:475:in 'LanguageOperator::Agent::TaskExecutor#execute_single_attempt'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:408:in 'LanguageOperator::Agent::TaskExecutor#execute_with_retry'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:126:in 'block in LanguageOperator::Agent::TaskExecutor#execute_task'", "/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/instrumentation.rb:45:in 'block in LanguageOperator::Agent::Instrumentation#with_span'", "/usr/lib/ruby/gems/3.4.0/gems/opentelemetry-api-1.7.0/lib/opentelemetry/trace/tracer.rb:37:in 'block in OpenTelemetry::Trace::Tracer#in_span'"])
|
|
13
|
+
Error loading agent code: Task 'generate_fortune' execution failed: timed out after 120.0s
|
|
14
|
+
/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:475:in 'LanguageOperator::Agent::TaskExecutor#execute_single_attempt'
|
|
15
|
+
/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:408:in 'LanguageOperator::Agent::TaskExecutor#execute_with_retry'
|
|
16
|
+
/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/task_executor.rb:126:in 'block in LanguageOperator::Agent::TaskExecutor#execute_task'
|
|
17
|
+
/usr/lib/ruby/gems/3.4.0/gems/language-operator-0.1.46/lib/language_operator/agent/instrumentation.rb:45:in 'block in LanguageOperator::Agent::Instrumentation#with_span'
|
|
18
|
+
/usr/lib/ruby/gems/3.4.0/gems/opentelemetry-api-1.7.0/lib/opentelemetry/trace/tracer.rb:37:in 'block in OpenTelemetry::Trace::Tracer#in_span'
|
|
19
|
+
No fallback configured, exiting
|
|
20
|
+
[31m✗ Agent failed with exit code: 1[0m
|
|
21
|
+
|
|
22
|
+
|
metadata
CHANGED
|
@@ -1,7 +1,7 @@
|
|
|
1
1
|
--- !ruby/object:Gem::Specification
|
|
2
2
|
name: language-operator
|
|
3
3
|
version: !ruby/object:Gem::Version
|
|
4
|
-
version: 0.1.
|
|
4
|
+
version: 0.1.47
|
|
5
5
|
platform: ruby
|
|
6
6
|
authors:
|
|
7
7
|
- James Ryan
|
|
@@ -409,6 +409,7 @@ executables:
|
|
|
409
409
|
extensions: []
|
|
410
410
|
extra_rdoc_files: []
|
|
411
411
|
files:
|
|
412
|
+
- ".claude/commands/task.md"
|
|
412
413
|
- ".rubocop.yml"
|
|
413
414
|
- CHANGELOG.md
|
|
414
415
|
- Gemfile
|
|
@@ -421,6 +422,30 @@ files:
|
|
|
421
422
|
- completions/_aictl
|
|
422
423
|
- completions/aictl.bash
|
|
423
424
|
- completions/aictl.fish
|
|
425
|
+
- components/agent/.rubocop.yml
|
|
426
|
+
- components/agent/Dockerfile
|
|
427
|
+
- components/agent/Dockerfile.dev
|
|
428
|
+
- components/agent/Gemfile
|
|
429
|
+
- components/agent/Makefile
|
|
430
|
+
- components/agent/bin/langop-agent
|
|
431
|
+
- components/agent/config/config.yaml
|
|
432
|
+
- components/base/Dockerfile
|
|
433
|
+
- components/base/Makefile
|
|
434
|
+
- components/base/entrypoint.sh
|
|
435
|
+
- components/base/gem-credentials
|
|
436
|
+
- components/tool/.gitignore
|
|
437
|
+
- components/tool/.rubocop.yml
|
|
438
|
+
- components/tool/.yardopts
|
|
439
|
+
- components/tool/Dockerfile
|
|
440
|
+
- components/tool/Dockerfile.dev
|
|
441
|
+
- components/tool/Gemfile
|
|
442
|
+
- components/tool/Makefile
|
|
443
|
+
- components/tool/README.md
|
|
444
|
+
- components/tool/config.ru
|
|
445
|
+
- components/tool/examples/calculator.rb
|
|
446
|
+
- components/tool/examples/example_tool.rb
|
|
447
|
+
- components/tool/lib/langop/dsl.rb
|
|
448
|
+
- components/tool/server.rb
|
|
424
449
|
- docs/architecture/agent-runtime.md
|
|
425
450
|
- docs/dsl/SCHEMA_VERSION.md
|
|
426
451
|
- docs/dsl/agent-reference.md
|
|
@@ -463,6 +488,7 @@ files:
|
|
|
463
488
|
- lib/language_operator/cli/errors/suggestions.rb
|
|
464
489
|
- lib/language_operator/cli/formatters/code_formatter.rb
|
|
465
490
|
- lib/language_operator/cli/formatters/log_formatter.rb
|
|
491
|
+
- lib/language_operator/cli/formatters/log_style.rb
|
|
466
492
|
- lib/language_operator/cli/formatters/progress_formatter.rb
|
|
467
493
|
- lib/language_operator/cli/formatters/status_formatter.rb
|
|
468
494
|
- lib/language_operator/cli/formatters/table_formatter.rb
|
|
@@ -537,11 +563,15 @@ files:
|
|
|
537
563
|
- lib/language_operator/validators.rb
|
|
538
564
|
- lib/language_operator/version.rb
|
|
539
565
|
- synth/001/Makefile
|
|
566
|
+
- synth/001/README.md
|
|
540
567
|
- synth/001/agent.rb
|
|
541
568
|
- synth/001/agent.txt
|
|
542
569
|
- synth/001/output.log
|
|
543
|
-
- synth/Makefile
|
|
544
|
-
- synth/README.md
|
|
570
|
+
- synth/002/Makefile
|
|
571
|
+
- synth/002/README.md
|
|
572
|
+
- synth/002/agent.rb
|
|
573
|
+
- synth/002/agent.txt
|
|
574
|
+
- synth/002/output.log
|
|
545
575
|
homepage: https://github.com/language-operator/language-operator
|
|
546
576
|
licenses:
|
|
547
577
|
- FSL-1.1-Apache-2.0
|
data/synth/Makefile
DELETED
|
@@ -1,39 +0,0 @@
|
|
|
1
|
-
.PHONY: test test-all clean help list
|
|
2
|
-
|
|
3
|
-
help:
|
|
4
|
-
@echo "Synthesis Test Suite"
|
|
5
|
-
@echo ""
|
|
6
|
-
@echo "Available targets:"
|
|
7
|
-
@echo " make test - Run synthesis for all test cases"
|
|
8
|
-
@echo " make test-all - Run synthesis for all models in all test cases"
|
|
9
|
-
@echo " make clean - Clean all generated files"
|
|
10
|
-
@echo " make list - List all test cases"
|
|
11
|
-
@echo ""
|
|
12
|
-
@echo "Individual test cases:"
|
|
13
|
-
@echo " make test-001 - Run test 001 (hello-world)"
|
|
14
|
-
@echo ""
|
|
15
|
-
@echo "Usage:"
|
|
16
|
-
@echo " cd 001 && make synthesize - Synthesize single test with default model"
|
|
17
|
-
@echo " cd 001 && make synthesize-all - Synthesize with all models"
|
|
18
|
-
@echo " cd 001 && make run - Execute synthesized code"
|
|
19
|
-
|
|
20
|
-
test:
|
|
21
|
-
@echo "Running synthesis tests..."
|
|
22
|
-
@$(MAKE) -C 001 synthesize
|
|
23
|
-
|
|
24
|
-
test-001:
|
|
25
|
-
@echo "Running test 001..."
|
|
26
|
-
@$(MAKE) -C 001 synthesize
|
|
27
|
-
|
|
28
|
-
test-all:
|
|
29
|
-
@echo "Running synthesis with all models..."
|
|
30
|
-
@$(MAKE) -C 001 synthesize-all
|
|
31
|
-
|
|
32
|
-
clean:
|
|
33
|
-
@echo "Cleaning all test artifacts..."
|
|
34
|
-
@$(MAKE) -C 001 clean
|
|
35
|
-
@echo "Clean complete!"
|
|
36
|
-
|
|
37
|
-
list:
|
|
38
|
-
@echo "Available test cases:"
|
|
39
|
-
@echo " 001 - hello-world (Say something in your logs)"
|