先跟完一次 order.py

func demoTools() spine.Manifest {
	// Host owns this immutable snapshot. No tool is available unless registered.
	catalog := map[string]any{"book": 21, "pen": 3, "shipping": 5, "choose": "pen"}
	return spine.Manifest{"lookup": {Call: func(ctx context.Context, args json.RawMessage) (any, error) {
		var a struct {
			Key string `json:"key"`
		}
		if err := json.Unmarshal(args, &a); err != nil {
			return nil, err
		}
		price, ok := catalog[a.Key]
		if !ok {
			return nil, fmt.Errorf("missing key: %s", a.Key)
		}
		return price, nil
	}, AllowEarlyRead: true}}

func main() {
	artifact := flag.String("wasm", "dist/spine.wasm", "real CPython Wasm artifact")
	source := flag.String("source", "examples/lookup.py", "Python source")
	input := flag.String("inputs", `{"item":"book","quantity":2}`, "JSON inputs")
	plm := flag.Bool("plm", false, "prepare allowed snapshot reads early")
	show := flag.Bool("show-transformed", false, "print the actual Guest AST rendering to stderr")
	prefix := flag.Bool("prefix", false, "demo append-only source delivery in line fragments")
	prepared := flag.Bool("prepared-copy", false, "clone clean initialized memory by full copy; not COW")
	preparedCOW := flag.Bool("prepared-cow", false, "share clean initialized Linux memory with MAP_PRIVATE COW")
	flag.Parse()
	if err := runWithMode(*artifact, *source, *input, *plm, *show, *prefix, *prepared, *preparedCOW); err != nil {
		fmt.Fprintln(os.Stderr, err)
		os.Exit(1)
	}
}

func run(artifact, source, input string, plm, show, prefix, prepared bool) error {
	return runWithMode(artifact, source, input, plm, show, prefix, prepared, false)
}

func runWithMode(artifact, source, input string, plm, show, prefix, prepared, preparedCOW bool) error {
	if prepared && preparedCOW {
		return fmt.Errorf("-prepared-copy and -prepared-cow are mutually exclusive")
	}
	wasm, err := os.ReadFile(artifact)
	if err != nil {
		return err
	}
	code, err := os.ReadFile(source)
	if err != nil {
		return err
	}
	var inputs any
	if err := json.Unmarshal([]byte(input), &inputs); err != nil {
		return err
	}
	tools := demoTools()
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	newRunner := spine.New
	if prepared {
		newRunner = spine.NewPrepared
	} else if preparedCOW {
		newRunner = spine.NewPreparedCOW
	}
	runner, err := newRunner(ctx, wasm, tools)
	if err != nil {
		return err
	}
	defer runner.Close(context.Background())

	var out spine.Output
	if prefix {
		// File replay is a small demo producer, not an LLM provider integration.
		chunks := make(chan string)
		go func() {
			defer close(chunks)
			for _, part := range strings.SplitAfter(string(code), "\n") {
				select {
				case chunks <- part:
				case <-ctx.Done():
					return
				}
			}
		}()
		out, err = runner.RunPrefix(ctx, chunks, inputs)
	} else {
		execute := runner.Run
		if plm {
			execute = runner.RunPLM
		}
		out, err = execute(ctx, string(code), inputs)
	}