<dependency>
    <groupId>dev.jamjet</groupId>
    <artifactId>jamjet-spring-boot-starter</artifactId>
    <version>0.1.0</version>
</dependency>

implementation("dev.jamjet:jamjet-spring-boot-starter:0.1.0")

implementation 'dev.jamjet:jamjet-spring-boot-starter:0.1.0'

docker run -p 7700:7700 ghcr.io/jamjet-labs/jamjet:latest

jamjet dev

spring:
  jamjet:
    runtime-url: http://localhost:7700
    # api-token: ${JAMJET_API_TOKEN}      # optional, for authenticated runtimes
    # tenant-id: default                   # multi-tenant isolation
    durability-enabled: true               # default: true
    connect-timeout-seconds: 10            # default: 10
    read-timeout-seconds: 120              # default: 120

spring.jamjet.runtime-url=http://localhost:7700

sequenceDiagram
    participant App as Spring App
    participant Advisor as DurabilityAdvisor
    participant Runtime as JamJet Runtime
    participant LLM as LLM Provider

    Note over App,LLM: First run (steps 1-6 succeed)
    App->>Advisor: chatClient.prompt("Analyze portfolio")
    Advisor->>Runtime: startExecution(workflowId)
    Runtime-->>Advisor: executionId
    Advisor->>LLM: Step 1: Generate plan
    LLM-->>Advisor: Plan response
    Advisor->>Runtime: Event: step 1 completed
    Advisor->>LLM: Steps 2-6...
    Advisor->>Runtime: Events: steps 2-6 completed

    Note over App,LLM: CRASH at step 7
    App-xAdvisor: Process killed

    Note over App,LLM: Restart and recovery
    App->>Advisor: chatClient.prompt("Analyze portfolio")
    Advisor->>Runtime: getExecution(executionId)
    Runtime-->>Advisor: status=Running, 6 events
    Note over Advisor: Replay events 1-6 (no LLM calls)
    Advisor->>LLM: Resume at step 7
    LLM-->>Advisor: Step 7 response
    Advisor->>Runtime: Event: step 7 completed
    Advisor->>LLM: Step 8
    LLM-->>Advisor: Final response
    Advisor->>Runtime: Event: execution completed
    Advisor-->>App: ChatClientResponse

@Bean
ChatClient chatClient(ChatClient.Builder builder) {
    return builder.build();
}

@Bean
CommandLineRunner demo(ChatClient chatClient) {
    return args -> {
        String result = chatClient.prompt("Summarize AI trends")
                .call()
                .content();
        System.out.println(result);
        // If the process crashes here, everything is lost
    };
}

@Bean
ChatClient chatClient(ChatClient.Builder builder) {
    return builder.build(); // JamjetDurabilityAdvisor auto-injected
}

@Bean
CommandLineRunner demo(ChatClient chatClient) {
    return args -> {
        String result = chatClient.prompt("Summarize AI trends")
                .call()
                .content();
        System.out.println(result);
        // Durable — survives crashes, events persisted, execution tracked
    };
}

{
  "type": "prompt",
  "advisor": "JamjetAuditAdvisor",
  "content": "Analyze the risk profile of portfolio XYZ-1234"
}

{
  "type": "response",
  "advisor": "JamjetAuditAdvisor",
  "content": "Based on the current allocation, portfolio XYZ-1234 has...",
  "prompt_tokens": 847,
  "completion_tokens": 1203,
  "total_tokens": 2050
}

spring:
  jamjet:
    audit:
      enabled: true              # default: true
      include-prompts: true      # default: true — log full prompt text
      include-responses: true    # default: true — log full response text

spring:
  jamjet:
    audit:
      enabled: true
      include-prompts: false     # omit prompt text from audit events
      include-responses: false   # omit response text from audit events

spring:
  jamjet:
    approval:
      enabled: true
      webhook-url: https://hooks.slack.com/services/T.../B.../xxx  # optional
      timeout: 30m            # default: 30m (supports s, m, h suffixes)
      default-decision: rejected   # default: rejected — what happens on timeout

String result = chatClient.prompt("Transfer $50,000 to account 9876")
        .advisors(approvalAdvisor)  // or auto-injected
        .context("jamjet.approval.required", true)
        .call()
        .content();
// Thread blocks here until approval is received (or timeout)

sequenceDiagram
    participant User as User/Client
    participant App as Spring App
    participant Advisor as ApprovalAdvisor
    participant Registry as ApprovalWaitRegistry
    participant Controller as /jamjet/approvals
    participant Reviewer as Human Reviewer

    User->>App: chatClient.prompt("Transfer $50K")
    App->>Advisor: before() — REQUIRES_APPROVAL=true
    Advisor->>Registry: waitForApproval(executionId, 30m)
    Note over Advisor,Registry: Thread blocks (durable pause)

    Note over Controller,Reviewer: Meanwhile, reviewer is notified
    Reviewer->>Controller: POST /jamjet/approvals/{executionId}
    Note right of Reviewer: {"decision":"approved","user_id":"jane"}
    Controller->>Registry: complete(executionId, decision)
    Registry-->>Advisor: ApprovalDecision(approved)

    Note over Advisor: Approval received — continue
    Advisor->>App: proceed with ChatClient call
    App-->>User: "Transfer initiated..."

curl -X POST http://localhost:8080/jamjet/approvals/{executionId} \
  -H "Content-Type: application/json" \
  -d '{
    "decision": "approved",
    "user_id": "jane.doe",
    "comment": "Reviewed and approved"
  }'

curl -X POST http://localhost:8080/jamjet/approvals/{executionId} \
  -H "Content-Type: application/json" \
  -d '{
    "decision": "rejected",
    "user_id": "jane.doe",
    "comment": "Amount exceeds policy limit"
  }'

curl http://localhost:8080/jamjet/approvals/pending

<dependency>
    <groupId>dev.jamjet</groupId>
    <artifactId>jamjet-spring-boot-starter-test</artifactId>
    <version>0.1.0</version>
    <scope>test</scope>
</dependency>

import dev.jamjet.spring.test.annotations.WithJamjetRuntime;
import dev.jamjet.spring.test.annotations.ReplayExecution;
import dev.jamjet.spring.test.RecordedExecution;
import dev.jamjet.spring.test.AgentAssertions;
import org.junit.jupiter.api.Test;
import java.util.concurrent.TimeUnit;

@WithJamjetRuntime
class PortfolioAgentTest {

    @Test
    @ReplayExecution("exec-abc123")
    void agentProducesConsistentOutput(RecordedExecution execution) {
        AgentAssertions.assertThat(execution)
                .completedSuccessfully()
                .usedTool("WebSearch")
                .completedWithin(30, TimeUnit.SECONDS)
                .costLessThan(0.50);
    }

    @Test
    @ReplayExecution(value = "exec-abc123", forkAtNode = "retrieve")
    void forkAndRerunFromRetrieveStep(RecordedExecution execution) {
        AgentAssertions.assertThat(execution)
                .nodeCompleted("retrieve")
                .outputContains("portfolio");
    }
}

@WithJamjetRuntime(image = "ghcr.io/jamjet-labs/jamjet", tag = "0.3.1")

import dev.jamjet.spring.test.DeterministicModelStub;

var stub = DeterministicModelStub.builder()
        .onPromptContaining("weather", "Sunny, 72F in San Francisco")
        .onPromptContaining("stock price", "ACME: $142.50, up 2.3%")
        .defaultResponse("I don't have information about that topic.")
        .build();

// Use as a ChatModel in your Spring context
@Bean
ChatModel chatModel() {
    return stub;
}

assertEquals(3, stub.getCallCount());
assertEquals("weather in SF", stub.getCalls().get(0).getContents());
stub.reset(); // clear call history

spring:
  jamjet:
    observability:
      micrometer: true           # default: true
      metric-prefix: jamjet      # default: jamjet

spring:
  jamjet:
    observability:
      opentelemetry: true        # default: false (opt-in)

graph TD
    A["jamjet.execution<br/>executionId, workflowId"] --> B["jamjet.node.retrieve<br/>nodeId, nodeKind"]
    A --> C["jamjet.node.synthesize<br/>nodeId, nodeKind"]
    B --> D["jamjet.tool.WebSearch<br/>toolName"]
    C --> E["jamjet.model.call<br/>modelName"]

<dependencies>
    <!-- Spring AI + OpenAI -->
    <dependency>
        <groupId>org.springframework.ai</groupId>
        <artifactId>spring-ai-openai-spring-boot-starter</artifactId>
    </dependency>

    <!-- JamJet durability -->
    <dependency>
        <groupId>dev.jamjet</groupId>
        <artifactId>jamjet-spring-boot-starter</artifactId>
        <version>0.1.0</version>
    </dependency>

    <!-- Spring Boot Actuator (enables Micrometer metrics) -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-actuator</artifactId>
    </dependency>

    <!-- Test -->
    <dependency>
        <groupId>dev.jamjet</groupId>
        <artifactId>jamjet-spring-boot-starter-test</artifactId>
        <version>0.1.0</version>
        <scope>test</scope>
    </dependency>
</dependencies>

spring:
  ai:
    openai:
      api-key: ${OPENAI_API_KEY}

  jamjet:
    runtime-url: http://localhost:7700
    durability-enabled: true

    audit:
      enabled: true
      include-prompts: true
      include-responses: true

    approval:
      enabled: true
      timeout: 15m
      default-decision: rejected

    observability:
      micrometer: true
      metric-prefix: jamjet

import dev.jamjet.spring.advisor.JamjetApprovalAdvisor;
import org.springframework.ai.chat.client.ChatClient;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.bind.annotation.*;

@SpringBootApplication
public class DurableAgentApplication {

    public static void main(String[] args) {
        SpringApplication.run(DurableAgentApplication.class, args);
    }

    @Bean
    ChatClient chatClient(ChatClient.Builder builder) {
        return builder.build(); // Durability + audit advisors auto-injected
    }

    @RestController
    @RequestMapping("/api/agent")
    static class AgentController {

        private final ChatClient chatClient;

        AgentController(ChatClient chatClient) {
            this.chatClient = chatClient;
        }

        // Standard durable call — crash recovery + audit trail
        @PostMapping("/ask")
        String ask(@RequestBody String prompt) {
            return chatClient.prompt(prompt)
                    .call()
                    .content();
        }

        // High-stakes call — requires human approval before proceeding
        @PostMapping("/ask-with-approval")
        String askWithApproval(@RequestBody String prompt) {
            return chatClient.prompt(prompt)
                    .context(JamjetApprovalAdvisor.REQUIRES_APPROVAL_KEY, true)
                    .call()
                    .content();
        }
    }
}

# Terminal 1: Start JamJet runtime
docker run -p 7700:7700 ghcr.io/jamjet-labs/jamjet:latest

# Terminal 2: Start the Spring Boot app
export OPENAI_API_KEY=sk-...
mvn spring-boot:run

# Terminal 3: Make a durable call
curl -X POST http://localhost:8080/api/agent/ask \
  -H "Content-Type: text/plain" \
  -d "What are the top 3 AI trends in 2026?"

# Make a call that requires approval
curl -X POST http://localhost:8080/api/agent/ask-with-approval \
  -H "Content-Type: text/plain" \
  -d "Draft an email to all customers about a pricing change"

# In another terminal: approve the pending execution
curl http://localhost:8080/jamjet/approvals/pending
# Copy the executionId from the response, then:
curl -X POST http://localhost:8080/jamjet/approvals/{executionId} \
  -H "Content-Type: application/json" \
  -d '{"decision":"approved","user_id":"admin","comment":"Looks good"}'